From c8bdcb777e698e953d19bfb4c0e8b43712551b64 Mon Sep 17 00:00:00 2001 From: Philippe Coval Date: Wed, 17 Sep 2025 15:53:13 +0200 Subject: [PATCH 01/60] p/UnifySDK: UIC-3222: Add U3C patches Signed-off-by: Philippe Coval --- ...-Allow-to-regenerate-files-using-zap.patch | 37 + ...IC-3222-Unify_UserCredential-cluster.patch | 129736 +++++++++++++++ ...serCredential-cluster-integration-in.patch | 997 + ...222-Allow-to-change-parent-of-a-node.patch | 252 + ...C-3222-Allow-to-send-toast-to-the-UI.patch | 108 + .../UnifySDK/0012-UIC-3222-Sonar-fixes.patch | 58 + .../0013-UIC-3222-Admin-PIN-Code-UI.patch | 38 + ...egenerate-U3C-zap-files-using-latest.patch | 75283 +++++++++ 8 files changed, 206509 insertions(+) create mode 100644 patches/UnifySDK/0007-fix-build-Allow-to-regenerate-files-using-zap.patch create mode 100644 patches/UnifySDK/0008-UIC-3222-Unify_UserCredential-cluster.patch create mode 100644 patches/UnifySDK/0009-UIC-3222-Unify_UserCredential-cluster-integration-in.patch create mode 100644 patches/UnifySDK/0010-UIC-3222-Allow-to-change-parent-of-a-node.patch create mode 100644 patches/UnifySDK/0011-UIC-3222-Allow-to-send-toast-to-the-UI.patch create mode 100644 patches/UnifySDK/0012-UIC-3222-Sonar-fixes.patch create mode 100644 patches/UnifySDK/0013-UIC-3222-Admin-PIN-Code-UI.patch create mode 100644 patches/UnifySDK/0014-UIC-3222-Regenerate-U3C-zap-files-using-latest.patch diff --git a/patches/UnifySDK/0007-fix-build-Allow-to-regenerate-files-using-zap.patch b/patches/UnifySDK/0007-fix-build-Allow-to-regenerate-files-using-zap.patch new file mode 100644 index 000000000..49e2f7541 --- /dev/null +++ b/patches/UnifySDK/0007-fix-build-Allow-to-regenerate-files-using-zap.patch @@ -0,0 +1,37 @@ +From f1b677b4127c8776244b272bcf20c9afeebe5522 Mon Sep 17 00:00:00 2001 +From: Philippe Coval +Date: Mon, 15 Sep 2025 10:43:26 +0200 +Subject: [PATCH] fix(build): Allow to regenerate files using zap + +For the record, files can be regenerated from developer using: + + rm -rf build ; cmake_options=-DZAP_GENERATE=ON ./helper.mk + +For some reasons developer will have to commit also generated files, +which is a bad practice, but I believe it was intentional to avoid +propagation to zap as build dependency, this may be revised to avoid +serialization of development. + +Relate-to: https://github.com/project-chip/zap/releases/download/v2025.07.24/zap-linux-x64.deb +Bug-SiliconLabs: UIC-3222 +Signed-off-by: Philippe Coval +--- + helper.mk | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/helper.mk b/helper.mk +index be052d5af6..75d1051981 100755 +--- a/helper.mk ++++ b/helper.mk +@@ -16,7 +16,7 @@ project?=unifysdk + BUILD_DEV_GUI?=OFF + BUILD_IMAGE_PROVIDER?=ON + +-cmake_options?=-B ${build_dir} ++cmake_options+=-B ${build_dir} + + CMAKE_GENERATOR?=Ninja + export CMAKE_GENERATOR +-- +2.39.5 + diff --git a/patches/UnifySDK/0008-UIC-3222-Unify_UserCredential-cluster.patch b/patches/UnifySDK/0008-UIC-3222-Unify_UserCredential-cluster.patch new file mode 100644 index 000000000..397d715c1 --- /dev/null +++ b/patches/UnifySDK/0008-UIC-3222-Unify_UserCredential-cluster.patch @@ -0,0 +1,129736 @@ +From 8fc5acac327300e41830f897cbf64e8d869dfb6c Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Tue, 17 Sep 2024 11:39:20 +0200 +Subject: [PATCH] UIC-3222: Unify_UserCredential cluster + +UIC-3222: Update Unify_UserCredential cluster +UIC-3222: CredentialLearn in Cluster +UIC-3222: Generated files for new version of cluster +UIC-3222: Cluster generation for Credential Association +UIC-3222: Updated cluster for Checksum +UIC-3222: Updated cluster for AdminCode +--- + .../cluster-types/cluster-type-attributes.ts | 1019 +- + .../src/cluster-types/cluster-types.ts | 3 +- + .../src/cluster-types/supported-clusters.js | 3 +- + .../dotdot-xml/Unify_UserCredential.xml | 236 + + components/uic_dotdot/dotdot-xml/library.xml | 2 + + components/uic_dotdot/zap/addon-helper.js | 1 - + .../zap-generated/include/dotdot_mqtt.h | 4526 ++- + .../include/dotdot_mqtt_attributes.h | 891 +- + .../include/dotdot_mqtt_generated_commands.h | 422 + + .../include/dotdot_mqtt_group_commands.h | 332 + + .../include/dotdot_mqtt_helpers.h | 35 + + .../include/dotdot_mqtt_helpers.hpp | 85 + + .../include/dotdot_mqtt_send_commands.h | 740 + + ...dotdot_mqtt_supported_generated_commands.h | 48 + + .../zap-generated/src/dotdot_mqtt.cpp | 33359 +++++++++------- + .../zap-generated/src/dotdot_mqtt.hpp | 466 +- + .../src/dotdot_mqtt_attributes.cpp | 2865 +- + .../src/dotdot_mqtt_command_helpers.cpp | 2445 +- + .../src/dotdot_mqtt_command_helpers.hpp | 991 +- + .../src/dotdot_mqtt_generated_commands.cpp | 740 + + .../src/dotdot_mqtt_group_commands.cpp | 2438 +- + .../zap-generated/src/dotdot_mqtt_helpers.cpp | 380 + + .../src/dotdot_mqtt_send_commands.cpp | 1440 + + ...tdot_mqtt_supported_generated_commands.cpp | 103 + + .../test/dotdot_mqtt_test.include | 859 +- + .../include/dotdot_attributes.uam | 10 + + .../include/dotdot_attributes_camel_case.uam | 10 + + .../unify_dotdot_attribute_store_helpers.h | 2435 +- + .../unify_dotdot_defined_attribute_types.h | 9 + + ...ot_attribute_store_attribute_publisher.cpp | 2145 +- + ..._force_read_attributes_command_callbacks.c | 67 + + .../unify_dotdot_attribute_store_helpers.cpp | 4030 +- + ...fy_dotdot_attribute_store_registration.cpp | 2526 +- + ...store_write_attributes_command_callbacks.c | 33 + + .../test/unify_dotdot_attribute_store_test.c | 1834 +- + .../test/unify_dotdot_attribute_store_test.h | 64 + + 36 files changed, 44849 insertions(+), 22743 deletions(-) + create mode 100644 components/uic_dotdot/dotdot-xml/Unify_UserCredential.xml + +diff --git a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-type-attributes.ts b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-type-attributes.ts +index a46049dbe7..b7c05cde83 100644 +--- a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-type-attributes.ts ++++ b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-type-attributes.ts +@@ -1,8 +1,8 @@ + //This file is generated automatically. Don't try to change something here. + //To add support for new clusters, modify addon-helper.js + //To change the stucture of the ClusterTypeAttrs, modify cluster-type-attributes.zapt +- +- ++ ++ + //generate ClusterTypes + export let ClusterTypeAttrs: any = { + Basic: { +@@ -15206,6 +15206,1021 @@ export let ClusterTypeAttrs: any = { + ] + } + }, ++ UserCredential: { ++ server:{ ++ attributes: [ ++ { ++ id: 0, ++ name: "SupportedUserUniqueIdentifiers", ++ type: "number", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ }, ++ { ++ id: 1, ++ name: "SupportedCredentialRules", ++ type: "bitmap", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ bitmap: [ ++ { name: "Single", mask: 2, type: "boolean", offset: 1 }, ++ { name: "Dual", mask: 4, type: "boolean", offset: 2 }, ++ { name: "Triple", mask: 8, type: "boolean", offset: 3 } ++ ] ++ }, ++ { ++ id: 2, ++ name: "SupportedCredentialTypes", ++ type: "bitmap", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ bitmap: [ ++ { name: "PINCode", mask: 1, type: "boolean", offset: 0 }, ++ { name: "Password", mask: 2, type: "boolean", offset: 1 }, ++ { name: "RFIDCode", mask: 4, type: "boolean", offset: 2 }, ++ { name: "BLE", mask: 8, type: "boolean", offset: 3 }, ++ { name: "NFC", mask: 16, type: "boolean", offset: 4 }, ++ { name: "UWB", mask: 32, type: "boolean", offset: 5 }, ++ { name: "EyeBiometric", mask: 64, type: "boolean", offset: 6 }, ++ { name: "FaceBiometric", mask: 128, type: "boolean", offset: 7 }, ++ { name: "FingerBiometric", mask: 256, type: "boolean", offset: 8 }, ++ { name: "HandBiometric", mask: 512, type: "boolean", offset: 9 }, ++ { name: "UnspecifiedBiometric", mask: 1024, type: "boolean", offset: 10 } ++ ] ++ }, ++ { ++ id: 3, ++ name: "SupportedUserTypes", ++ type: "bitmap", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ bitmap: [ ++ { name: "GeneralUser", mask: 1, type: "boolean", offset: 0 }, ++ { name: "ProgrammingUser", mask: 8, type: "boolean", offset: 3 }, ++ { name: "NonAccessUser", mask: 16, type: "boolean", offset: 4 }, ++ { name: "DuressUser", mask: 32, type: "boolean", offset: 5 }, ++ { name: "DisposableUser", mask: 64, type: "boolean", offset: 6 }, ++ { name: "ExpiringUser", mask: 128, type: "boolean", offset: 7 }, ++ { name: "RemoteOnlyUser", mask: 512, type: "boolean", offset: 9 } ++ ] ++ }, ++ { ++ id: 4, ++ name: "SupportCredentialChecksum", ++ type: "boolean", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ }, ++ { ++ id: 5, ++ name: "SupportAdminPinCode", ++ type: "boolean", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ }, ++ { ++ id: 6, ++ name: "SupportAdminPinCodeDeactivation", ++ type: "boolean", ++ required: true, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ }, ++ { ++ id: 7, ++ name: "AdminPinCode", ++ type: "text", ++ required: false, ++ reportRequired: false, ++ sceneRequired: false, ++ writable: false, ++ isArray: false, ++ } ++ ], ++ commands: [ ++ { ++ id: 1, ++ name: "AddUser", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "UserType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "GeneralUser", ++ value: 0 ++ }, ++ { ++ name: "ProgrammingUser", ++ value: 3 ++ }, ++ { ++ name: "NonAccessUser", ++ value: 4 ++ }, ++ { ++ name: "DuressUser", ++ value: 5 ++ }, ++ { ++ name: "DisposableUser", ++ value: 6 ++ }, ++ { ++ name: "ExpiringUser", ++ value: 7 ++ }, ++ { ++ name: "RemoteOnlyUser", ++ value: 9 ++ } ++ ], ++ }, ++ { ++ name: "UserActiveState", ++ type: "boolean", ++ isArray: false, ++ }, ++ { ++ name: "CredentialRule", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "Single", ++ value: 1 ++ }, ++ { ++ name: "Dual", ++ value: 2 ++ }, ++ { ++ name: "Triple", ++ value: 3 ++ } ++ ], ++ }, ++ { ++ name: "UserName", ++ type: "text", ++ isArray: false, ++ }, ++ { ++ name: "ExpiringTimeoutMinutes", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "UserNameEncoding", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "ASCII", ++ value: 0 ++ }, ++ { ++ name: "OEMExtendedASCII", ++ value: 1 ++ }, ++ { ++ name: "UTF-16", ++ value: 2 ++ } ++ ], ++ } ++ ] ++ }, ++ { ++ id: 2, ++ name: "ModifyUser", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "UserType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "GeneralUser", ++ value: 0 ++ }, ++ { ++ name: "ProgrammingUser", ++ value: 3 ++ }, ++ { ++ name: "NonAccessUser", ++ value: 4 ++ }, ++ { ++ name: "DuressUser", ++ value: 5 ++ }, ++ { ++ name: "DisposableUser", ++ value: 6 ++ }, ++ { ++ name: "ExpiringUser", ++ value: 7 ++ }, ++ { ++ name: "RemoteOnlyUser", ++ value: 9 ++ } ++ ], ++ }, ++ { ++ name: "UserActiveState", ++ type: "boolean", ++ isArray: false, ++ }, ++ { ++ name: "CredentialRule", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "Single", ++ value: 1 ++ }, ++ { ++ name: "Dual", ++ value: 2 ++ }, ++ { ++ name: "Triple", ++ value: 3 ++ } ++ ], ++ }, ++ { ++ name: "UserName", ++ type: "text", ++ isArray: false, ++ }, ++ { ++ name: "ExpiringTimeoutMinutes", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "UserNameEncoding", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "ASCII", ++ value: 0 ++ }, ++ { ++ name: "OEMExtendedASCII", ++ value: 1 ++ }, ++ { ++ name: "UTF-16", ++ value: 2 ++ } ++ ], ++ } ++ ] ++ }, ++ { ++ id: 3, ++ name: "DeleteUser", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 4, ++ name: "AddCredential", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "CredentialSlot", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialData", ++ type: "text", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 5, ++ name: "ModifyCredential", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "CredentialSlot", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialData", ++ type: "text", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 6, ++ name: "DeleteCredential", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "CredentialSlot", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 7, ++ name: "DeleteAllUsers", ++ required: false, ++ fields: [ ++ ] ++ }, ++ { ++ id: 8, ++ name: "DeleteAllCredentials", ++ required: false, ++ fields: [ ++ ] ++ }, ++ { ++ id: 9, ++ name: "DeleteAllCredentialsByType", ++ required: false, ++ fields: [ ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ } ++ ] ++ }, ++ { ++ id: 10, ++ name: "DeleteAllCredentialsForUser", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 11, ++ name: "DeleteAllCredentialsForUserByType", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ } ++ ] ++ }, ++ { ++ id: 12, ++ name: "CredentialLearnStartAdd", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "CredentialSlot", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialLearnTimeout", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 13, ++ name: "CredentialLearnStartModify", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "CredentialSlot", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "CredentialLearnTimeout", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 14, ++ name: "CredentialLearnStop", ++ required: false, ++ fields: [ ++ ] ++ }, ++ { ++ id: 15, ++ name: "CredentialAssociation", ++ required: false, ++ fields: [ ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ }, ++ { ++ name: "SourceUserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "SourceCredentialSlot", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "DestinationUserUniqueID", ++ type: "number", ++ isArray: false, ++ }, ++ { ++ name: "DestinationCredentialSlot", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 16, ++ name: "GetUserChecksum", ++ required: false, ++ fields: [ ++ { ++ name: "UserUniqueID", ++ type: "number", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 17, ++ name: "GetCredentialChecksum", ++ required: false, ++ fields: [ ++ { ++ name: "CredentialType", ++ type: "enum", ++ isArray: false, ++ enum:[ ++ { ++ name: "PINCode", ++ value: 1 ++ }, ++ { ++ name: "Password", ++ value: 2 ++ }, ++ { ++ name: "RFIDCode", ++ value: 3 ++ }, ++ { ++ name: "BLE", ++ value: 4 ++ }, ++ { ++ name: "NFC", ++ value: 5 ++ }, ++ { ++ name: "UWB", ++ value: 6 ++ }, ++ { ++ name: "EyeBiometric", ++ value: 7 ++ }, ++ { ++ name: "FaceBiometric", ++ value: 8 ++ }, ++ { ++ name: "FingerBiometric", ++ value: 9 ++ }, ++ { ++ name: "HandBiometric", ++ value: 10 ++ }, ++ { ++ name: "UnspecifiedBiometric", ++ value: 11 ++ } ++ ], ++ } ++ ] ++ }, ++ { ++ id: 18, ++ name: "GetAllUsersChecksum", ++ required: false, ++ fields: [ ++ ] ++ }, ++ { ++ id: 19, ++ name: "SetAdminPINCode", ++ required: false, ++ fields: [ ++ { ++ name: "PINCode", ++ type: "text", ++ isArray: false, ++ } ++ ] ++ }, ++ { ++ id: 20, ++ name: "DeactivateAdminPINCode", ++ required: false, ++ fields: [ ++ ] ++ } ++ ] ++ } ++ }, + NetworkManagement: { + server:{ + attributes: [ +diff --git a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-types.ts b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-types.ts +index 192c0f68f9..07b15f19c3 100644 +--- a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-types.ts ++++ b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/cluster-types.ts +@@ -30,7 +30,8 @@ export enum ClusterTypes { + TemperatureMeasurement = "TemperatureMeasurement", + Thermostat = "Thermostat", + WindSpeedMeasurement = "WindSpeedMeasurement", +- WindowCovering = "WindowCovering" ++ WindowCovering = "WindowCovering", ++ UserCredential = "UserCredential" + } + + export enum ControllerTypes { +diff --git a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/supported-clusters.js b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/supported-clusters.js +index e19a8e938b..9b34c42190 100644 +--- a/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/supported-clusters.js ++++ b/applications/dev_ui/dev_gui/zap-generated/src/cluster-types/supported-clusters.js +@@ -33,7 +33,8 @@ const SupportedClusters = { + TemperatureMeasurement: "TemperatureMeasurement", + Thermostat: "Thermostat", + WindSpeedMeasurement: "WindSpeedMeasurement", +- WindowCovering: "WindowCovering" ++ WindowCovering: "WindowCovering", ++ UserCredential: "UserCredential" + } + + module.exports.SupportedClusters = SupportedClusters; +\ No newline at end of file +diff --git a/components/uic_dotdot/dotdot-xml/Unify_UserCredential.xml b/components/uic_dotdot/dotdot-xml/Unify_UserCredential.xml +new file mode 100644 +index 0000000000..da1327a851 +--- /dev/null ++++ b/components/uic_dotdot/dotdot-xml/Unify_UserCredential.xml +@@ -0,0 +1,236 @@ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff --git a/components/uic_dotdot/dotdot-xml/library.xml b/components/uic_dotdot/dotdot-xml/library.xml +index 4210b67fa4..79e165dbc6 100644 +--- a/components/uic_dotdot/dotdot-xml/library.xml ++++ b/components/uic_dotdot/dotdot-xml/library.xml +@@ -501,4 +501,6 @@ applicable to this document can be found in the LICENSE.md file. + + + ++ ++ + +\ No newline at end of file +diff --git a/components/uic_dotdot/zap/addon-helper.js b/components/uic_dotdot/zap/addon-helper.js +index 3686fb8395..8e1629808b 100644 +--- a/components/uic_dotdot/zap/addon-helper.js ++++ b/components/uic_dotdot/zap/addon-helper.js +@@ -126,7 +126,6 @@ function isStruct(type) { + case 'NetworkManagementState': return true + case 'SSceneTable': return true + case 'DeviceTypeStruct': return true +- case 'CredentialStruct': return true + default: return false + } + } +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h +index bd703a2daf..47a3d4a00c 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h +@@ -111,17 +111,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_reset_to_factory_defaults_callback_t + ); + + typedef struct { +- uint8_t zcl_version; +- uint8_t application_version; +- uint8_t stack_version; +- uint8_t hw_version; ++ int8_t zcl_version; ++ int8_t application_version; ++ int8_t stack_version; ++ int8_t hw_version; + const char* manufacturer_name; + const char* model_identifier; + const char* date_code; + uint8_t power_source; + uint8_t generic_device_class; + uint8_t generic_device_type; +- const char* product_code; ++ uint8_t product_code; + const char* producturl; + const char* manufacturer_version_details; + const char* serial_number; +@@ -277,7 +277,7 @@ void uic_mqtt_dotdot_clear_basic_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_basic_zcl_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -307,7 +307,7 @@ sl_status_t uic_mqtt_dotdot_basic_zcl_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_application_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -337,7 +337,7 @@ sl_status_t uic_mqtt_dotdot_basic_application_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_stack_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -367,7 +367,7 @@ sl_status_t uic_mqtt_dotdot_basic_stack_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_hw_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -577,7 +577,7 @@ sl_status_t uic_mqtt_dotdot_basic_generic_device_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_product_code_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -942,62 +942,62 @@ void uic_mqtt_dotdot_basic_publish_empty_supported_commands( + // Callback types used by the power_configuration cluster + + typedef struct { +- uint16_t mains_voltage; +- uint8_t mains_frequency; ++ int16_t mains_voltage; ++ int8_t mains_frequency; + uint8_t mains_alarm_mask; +- uint16_t mains_voltage_min_threshold; +- uint16_t mains_voltage_max_threshold; +- uint16_t mains_voltage_dwell_trip_point; +- uint8_t battery_voltage; +- uint8_t battery_percentage_remaining; ++ int16_t mains_voltage_min_threshold; ++ int16_t mains_voltage_max_threshold; ++ int16_t mains_voltage_dwell_trip_point; ++ int8_t battery_voltage; ++ int8_t battery_percentage_remaining; + const char* battery_manufacturer; + uint8_t battery_size; +- uint16_t batterya_hr_rating; +- uint8_t battery_quantity; +- uint8_t battery_rated_voltage; ++ int16_t batterya_hr_rating; ++ int8_t battery_quantity; ++ int8_t battery_rated_voltage; + uint8_t battery_alarm_mask; +- uint8_t battery_voltage_min_threshold; +- uint8_t battery_voltage_threshold1; +- uint8_t battery_voltage_threshold2; +- uint8_t battery_voltage_threshold3; +- uint8_t battery_percentage_min_threshold; +- uint8_t battery_percentage_threshold1; +- uint8_t battery_percentage_threshold2; +- uint8_t battery_percentage_threshold3; ++ int8_t battery_voltage_min_threshold; ++ int8_t battery_voltage_threshold1; ++ int8_t battery_voltage_threshold2; ++ int8_t battery_voltage_threshold3; ++ int8_t battery_percentage_min_threshold; ++ int8_t battery_percentage_threshold1; ++ int8_t battery_percentage_threshold2; ++ int8_t battery_percentage_threshold3; + uint32_t battery_alarm_state; +- uint8_t battery2_voltage; +- uint8_t battery2_percentage_remaining; ++ int8_t battery2_voltage; ++ int8_t battery2_percentage_remaining; + const char* battery2_manufacturer; + uint8_t battery2_size; +- uint16_t battery2a_hr_rating; +- uint8_t battery2_quantity; +- uint8_t battery2_rated_voltage; ++ int16_t battery2a_hr_rating; ++ int8_t battery2_quantity; ++ int8_t battery2_rated_voltage; + uint8_t battery2_alarm_mask; +- uint8_t battery2_voltage_min_threshold; +- uint8_t battery2_voltage_threshold1; +- uint8_t battery2_voltage_threshold2; +- uint8_t battery2_voltage_threshold3; +- uint8_t battery2_percentage_min_threshold; +- uint8_t battery2_percentage_threshold1; +- uint8_t battery2_percentage_threshold2; +- uint8_t battery2_percentage_threshold3; ++ int8_t battery2_voltage_min_threshold; ++ int8_t battery2_voltage_threshold1; ++ int8_t battery2_voltage_threshold2; ++ int8_t battery2_voltage_threshold3; ++ int8_t battery2_percentage_min_threshold; ++ int8_t battery2_percentage_threshold1; ++ int8_t battery2_percentage_threshold2; ++ int8_t battery2_percentage_threshold3; + uint32_t battery2_alarm_state; +- uint8_t battery3_voltage; +- uint8_t battery3_percentage_remaining; ++ int8_t battery3_voltage; ++ int8_t battery3_percentage_remaining; + const char* battery3_manufacturer; + uint8_t battery3_size; +- uint16_t battery3a_hr_rating; +- uint8_t battery3_quantity; +- uint8_t battery3_rated_voltage; ++ int16_t battery3a_hr_rating; ++ int8_t battery3_quantity; ++ int8_t battery3_rated_voltage; + uint8_t battery3_alarm_mask; +- uint8_t battery3_voltage_min_threshold; +- uint8_t battery3_voltage_threshold1; +- uint8_t battery3_voltage_threshold2; +- uint8_t battery3_voltage_threshold3; +- uint8_t battery3_percentage_min_threshold; +- uint8_t battery3_percentage_threshold1; +- uint8_t battery3_percentage_threshold2; +- uint8_t battery3_percentage_threshold3; ++ int8_t battery3_voltage_min_threshold; ++ int8_t battery3_voltage_threshold1; ++ int8_t battery3_voltage_threshold2; ++ int8_t battery3_voltage_threshold3; ++ int8_t battery3_percentage_min_threshold; ++ int8_t battery3_percentage_threshold1; ++ int8_t battery3_percentage_threshold2; ++ int8_t battery3_percentage_threshold3; + uint32_t battery3_alarm_state; + } uic_mqtt_dotdot_power_configuration_state_t; + +@@ -1140,7 +1140,7 @@ void uic_mqtt_dotdot_clear_power_configuration_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1170,7 +1170,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1230,7 +1230,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1260,7 +1260,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1290,7 +1290,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1320,7 +1320,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1350,7 +1350,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1440,7 +1440,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1470,7 +1470,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1500,7 +1500,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1560,7 +1560,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1590,7 +1590,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1620,7 +1620,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1650,7 +1650,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1680,7 +1680,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1710,7 +1710,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1740,7 +1740,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1770,7 +1770,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1830,7 +1830,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1860,7 +1860,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1950,7 +1950,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1980,7 +1980,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2010,7 +2010,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2070,7 +2070,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2100,7 +2100,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2130,7 +2130,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2160,7 +2160,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2190,7 +2190,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2220,7 +2220,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshol + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2250,7 +2250,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2280,7 +2280,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2340,7 +2340,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2370,7 +2370,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2460,7 +2460,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2490,7 +2490,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2520,7 +2520,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2580,7 +2580,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2610,7 +2610,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2640,7 +2640,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2670,7 +2670,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2700,7 +2700,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2730,7 +2730,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshol + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2760,7 +2760,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2790,7 +2790,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2888,12 +2888,12 @@ typedef struct { + int16_t current_temperature; + int16_t min_temp_experienced; + int16_t max_temp_experienced; +- uint16_t over_temp_total_dwell; ++ int16_t over_temp_total_dwell; + uint8_t device_temp_alarm_mask; + int16_t low_temp_threshold; + int16_t high_temp_threshold; +- uint32_t low_temp_dwell_trip_point; +- uint32_t high_temp_dwell_trip_point; ++ int32_t low_temp_dwell_trip_point; ++ int32_t high_temp_dwell_trip_point; + } uic_mqtt_dotdot_device_temperature_configuration_state_t; + + typedef struct { +@@ -3077,7 +3077,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_max_temp_experience + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3197,7 +3197,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_threshold + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3227,7 +3227,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3294,14 +3294,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t identify_time ++ int16_t identify_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_query_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t timeout ++ int16_t timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_query_callback_t)( +@@ -3320,7 +3320,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_trigger_effect_callback_t)( + ); + + typedef struct { +- uint16_t identify_time; ++ int16_t identify_time; + } uic_mqtt_dotdot_identify_state_t; + + typedef struct { +@@ -3347,14 +3347,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_force_read_attributes_callback_t) + * @brief Command fields for Identify/Identify + */ + typedef struct { +- uint16_t identify_time; ++ int16_t identify_time; + } uic_mqtt_dotdot_identify_command_identify_fields_t; + + /** + * @brief Command fields for Identify/IdentifyQueryResponse + */ + typedef struct { +- uint16_t timeout; ++ int16_t timeout; + } uic_mqtt_dotdot_identify_command_identify_query_response_fields_t; + + /** +@@ -3589,7 +3589,7 @@ void uic_mqtt_dotdot_clear_identify_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_identify_identify_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3656,7 +3656,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -3667,14 +3667,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- uint16_t group_id ++ int16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t group_id ++ int16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_response_callback_t)( +@@ -3683,7 +3683,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -3693,24 +3693,24 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_get_group_membership_callback_t)( + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t group_list_count, +- const uint16_t *group_list ++ const int16_t *group_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_get_group_membership_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t capacity, ++ int8_t capacity, + + uint8_t group_list_count, +- const uint16_t *group_list ++ const int16_t *group_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t group_id ++ int16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_response_callback_t)( +@@ -3719,7 +3719,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- uint16_t group_id ++ int16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_all_groups_callback_t)( +@@ -3731,7 +3731,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_if_identifying_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -3765,7 +3765,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_force_read_attributes_callback_t)( + * @brief Command fields for Groups/AddGroup + */ + typedef struct { +- uint16_t group_id; ++ int16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_add_group_fields_t; +@@ -3776,14 +3776,14 @@ typedef struct { + typedef struct { + uint8_t status; + +- uint16_t group_id; ++ int16_t group_id; + } uic_mqtt_dotdot_groups_command_add_group_response_fields_t; + + /** + * @brief Command fields for Groups/ViewGroup + */ + typedef struct { +- uint16_t group_id; ++ int16_t group_id; + } uic_mqtt_dotdot_groups_command_view_group_fields_t; + + /** +@@ -3792,7 +3792,7 @@ typedef struct { + typedef struct { + uint8_t status; + +- uint16_t group_id; ++ int16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_view_group_response_fields_t; +@@ -3802,24 +3802,24 @@ typedef struct { + */ + typedef struct { + uint8_t group_list_count; +- const uint16_t *group_list; ++ const int16_t *group_list; + } uic_mqtt_dotdot_groups_command_get_group_membership_fields_t; + + /** + * @brief Command fields for Groups/GetGroupMembershipResponse + */ + typedef struct { +- uint8_t capacity; ++ int8_t capacity; + + uint8_t group_list_count; +- const uint16_t *group_list; ++ const int16_t *group_list; + } uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t; + + /** + * @brief Command fields for Groups/RemoveGroup + */ + typedef struct { +- uint16_t group_id; ++ int16_t group_id; + } uic_mqtt_dotdot_groups_command_remove_group_fields_t; + + /** +@@ -3828,14 +3828,14 @@ typedef struct { + typedef struct { + uint8_t status; + +- uint16_t group_id; ++ int16_t group_id; + } uic_mqtt_dotdot_groups_command_remove_group_response_fields_t; + + /** + * @brief Command fields for Groups/AddGroupIfIdentifying + */ + typedef struct { +- uint16_t group_id; ++ int16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_add_group_if_identifying_fields_t; +@@ -4370,18 +4370,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets, + +- uint8_t transition_time100ms ++ int8_t transition_time100ms + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_response_callback_t)( +@@ -4390,18 +4390,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_response_callback_t)( +@@ -4410,13 +4410,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4426,9 +4426,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_response_callback_t)( +@@ -4437,16 +4437,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid ++ uint8_t * groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_t)( +@@ -4455,16 +4455,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid ++ uint8_t * groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_response_callback_t)( +@@ -4473,27 +4473,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_recall_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time ++ int16_t transition_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid ++ uint8_t * groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_response_callback_t)( +@@ -4502,25 +4502,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_response_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t capacity, ++ int8_t capacity, + +- uint16_t groupid, ++ uint8_t * groupid, + + uint8_t scene_list_count, +- const uint8_t *scene_list ++ const int8_t *scene_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_add_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4532,18 +4532,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callbac + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback_t)( +@@ -4552,13 +4552,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callba + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4570,13 +4570,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t mode, + +- uint16_t group_identifier_from, ++ uint8_t * group_identifier_from, + +- uint8_t scene_identifier_from, ++ int8_t scene_identifier_from, + +- uint16_t group_identifier_to, ++ uint8_t * group_identifier_to, + +- uint8_t scene_identifier_to ++ int8_t scene_identifier_to + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_response_callback_t)( +@@ -4585,16 +4585,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint16_t group_identifier_from, ++ uint8_t * group_identifier_from, + +- uint8_t scene_identifier_from ++ int8_t scene_identifier_from + + ); + + typedef struct { +- uint8_t scene_count; +- uint8_t current_scene; +- uint16_t current_group; ++ int8_t scene_count; ++ int8_t current_scene; ++ uint8_t * current_group; + bool scene_valid; + uint8_t name_support; + uint64_t last_configured_by; +@@ -4632,18 +4632,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_force_read_attributes_callback_t)( + * @brief Command fields for Scenes/AddScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + +- uint16_t transition_time; ++ int16_t transition_time; + +- const char* scene_name; ++ uint8_t * scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; + +- uint8_t transition_time100ms; ++ int8_t transition_time100ms; + } uic_mqtt_dotdot_scenes_command_add_scene_fields_t; + + /** +@@ -4652,18 +4652,18 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_add_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/ViewScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_view_scene_fields_t; + + /** +@@ -4672,13 +4672,13 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + +- uint16_t transition_time; ++ int16_t transition_time; + +- const char* scene_name; ++ uint8_t * scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4688,9 +4688,9 @@ typedef struct { + * @brief Command fields for Scenes/RemoveScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_remove_scene_fields_t; + + /** +@@ -4699,16 +4699,16 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_remove_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/RemoveAllScenes + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + } uic_mqtt_dotdot_scenes_command_remove_all_scenes_fields_t; + + /** +@@ -4717,16 +4717,16 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + } uic_mqtt_dotdot_scenes_command_remove_all_scenes_response_fields_t; + + /** + * @brief Command fields for Scenes/StoreScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_store_scene_fields_t; + + /** +@@ -4735,27 +4735,27 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_store_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/RecallScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + +- uint16_t transition_time; ++ int16_t transition_time; + } uic_mqtt_dotdot_scenes_command_recall_scene_fields_t; + + /** + * @brief Command fields for Scenes/GetSceneMembership + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + } uic_mqtt_dotdot_scenes_command_get_scene_membership_fields_t; + + /** +@@ -4764,25 +4764,25 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t capacity; ++ int8_t capacity; + +- uint16_t groupid; ++ uint8_t * groupid; + + uint8_t scene_list_count; +- const uint8_t *scene_list; ++ const int8_t *scene_list; + } uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t; + + /** + * @brief Command fields for Scenes/EnhancedAddScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + +- uint16_t transition_time; ++ int16_t transition_time; + +- const char* scene_name; ++ uint8_t * scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4794,18 +4794,18 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_enhanced_add_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/EnhancedViewScene + */ + typedef struct { +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + } uic_mqtt_dotdot_scenes_command_enhanced_view_scene_fields_t; + + /** +@@ -4814,13 +4814,13 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t groupid; ++ uint8_t * groupid; + +- uint8_t sceneid; ++ int8_t sceneid; + +- uint16_t transition_time; ++ int16_t transition_time; + +- const char* scene_name; ++ uint8_t * scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4832,13 +4832,13 @@ typedef struct { + typedef struct { + uint8_t mode; + +- uint16_t group_identifier_from; ++ uint8_t * group_identifier_from; + +- uint8_t scene_identifier_from; ++ int8_t scene_identifier_from; + +- uint16_t group_identifier_to; ++ uint8_t * group_identifier_to; + +- uint8_t scene_identifier_to; ++ int8_t scene_identifier_to; + } uic_mqtt_dotdot_scenes_command_copy_scene_fields_t; + + /** +@@ -4847,9 +4847,9 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint16_t group_identifier_from; ++ uint8_t * group_identifier_from; + +- uint8_t scene_identifier_from; ++ int8_t scene_identifier_from; + } uic_mqtt_dotdot_scenes_command_copy_scene_response_fields_t; + + +@@ -5675,7 +5675,7 @@ void uic_mqtt_dotdot_clear_scenes_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_scenes_scene_count_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5705,7 +5705,7 @@ sl_status_t uic_mqtt_dotdot_scenes_scene_count_unretain( + */ + sl_status_t uic_mqtt_dotdot_scenes_current_scene_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5735,7 +5735,7 @@ sl_status_t uic_mqtt_dotdot_scenes_current_scene_unretain( + */ + sl_status_t uic_mqtt_dotdot_scenes_current_group_publish( + const char *base_topic, +- uint16_t value, ++ uint8_t * value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5941,7 +5941,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_off_with_effect_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + OffWithEffectEffectIdentifier effect_identifier, + +- uint8_t effect_variant ++ int8_t effect_variant + + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_on_with_recall_global_scene_callback_t)( +@@ -5955,17 +5955,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_on_with_timed_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t on_off_control, + +- uint16_t on_time, ++ int16_t on_time, + +- uint16_t off_wait_time ++ int16_t off_wait_time + + ); + + typedef struct { + bool on_off; + bool global_scene_control; +- uint16_t on_time; +- uint16_t off_wait_time; ++ int16_t on_time; ++ int16_t off_wait_time; + uint8_t start_up_on_off; + } uic_mqtt_dotdot_on_off_state_t; + +@@ -5999,7 +5999,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_force_read_attributes_callback_t)( + typedef struct { + OffWithEffectEffectIdentifier effect_identifier; + +- uint8_t effect_variant; ++ int8_t effect_variant; + } uic_mqtt_dotdot_on_off_command_off_with_effect_fields_t; + + /** +@@ -6008,9 +6008,9 @@ typedef struct { + typedef struct { + uint8_t on_off_control; + +- uint16_t on_time; ++ int16_t on_time; + +- uint16_t off_wait_time; ++ int16_t off_wait_time; + } uic_mqtt_dotdot_on_off_command_on_with_timed_off_fields_t; + + +@@ -6376,7 +6376,7 @@ sl_status_t uic_mqtt_dotdot_on_off_global_scene_control_unretain( + */ + sl_status_t uic_mqtt_dotdot_on_off_on_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -6406,7 +6406,7 @@ sl_status_t uic_mqtt_dotdot_on_off_on_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_on_off_off_wait_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -6503,9 +6503,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t level, ++ int8_t level, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -6518,7 +6518,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -6531,9 +6531,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_step_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -6553,9 +6553,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_level_with_on_off_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t level, ++ int8_t level, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -6568,7 +6568,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_with_on_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -6581,9 +6581,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_step_with_on_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -6603,25 +6603,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_closest_frequency_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t frequency ++ int16_t frequency + + ); + + typedef struct { +- uint8_t current_level; +- uint16_t remaining_time; +- uint8_t min_level; +- uint8_t max_level; +- uint16_t current_frequency; +- uint16_t min_frequency; +- uint16_t max_frequency; ++ int8_t current_level; ++ int16_t remaining_time; ++ int8_t min_level; ++ int8_t max_level; ++ int16_t current_frequency; ++ int16_t min_frequency; ++ int16_t max_frequency; + uint8_t options; +- uint16_t on_off_transition_time; +- uint8_t on_level; +- uint16_t on_transition_time; +- uint16_t off_transition_time; +- uint16_t default_move_rate; +- uint8_t start_up_current_level; ++ int16_t on_off_transition_time; ++ int8_t on_level; ++ int16_t on_transition_time; ++ int16_t off_transition_time; ++ int16_t default_move_rate; ++ int8_t start_up_current_level; + } uic_mqtt_dotdot_level_state_t; + + typedef struct { +@@ -6661,9 +6661,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_force_read_attributes_callback_t)( + * @brief Command fields for Level/MoveToLevel + */ + typedef struct { +- uint8_t level; ++ int8_t level; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -6676,7 +6676,7 @@ typedef struct { + typedef struct { + MoveStepMode move_mode; + +- uint8_t rate; ++ int8_t rate; + + uint8_t options_mask; + +@@ -6689,9 +6689,9 @@ typedef struct { + typedef struct { + MoveStepMode step_mode; + +- uint8_t step_size; ++ int8_t step_size; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -6711,9 +6711,9 @@ typedef struct { + * @brief Command fields for Level/MoveToLevelWithOnOff + */ + typedef struct { +- uint8_t level; ++ int8_t level; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -6726,7 +6726,7 @@ typedef struct { + typedef struct { + MoveStepMode move_mode; + +- uint8_t rate; ++ int8_t rate; + + uint8_t options_mask; + +@@ -6739,9 +6739,9 @@ typedef struct { + typedef struct { + MoveStepMode step_mode; + +- uint8_t step_size; ++ int8_t step_size; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -6761,7 +6761,7 @@ typedef struct { + * @brief Command fields for Level/MoveToClosestFrequency + */ + typedef struct { +- uint16_t frequency; ++ int16_t frequency; + } uic_mqtt_dotdot_level_command_move_to_closest_frequency_fields_t; + + +@@ -7187,7 +7187,7 @@ void uic_mqtt_dotdot_clear_level_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_level_current_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7217,7 +7217,7 @@ sl_status_t uic_mqtt_dotdot_level_current_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_remaining_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7247,7 +7247,7 @@ sl_status_t uic_mqtt_dotdot_level_remaining_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7277,7 +7277,7 @@ sl_status_t uic_mqtt_dotdot_level_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7307,7 +7307,7 @@ sl_status_t uic_mqtt_dotdot_level_max_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_current_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7337,7 +7337,7 @@ sl_status_t uic_mqtt_dotdot_level_current_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_min_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7367,7 +7367,7 @@ sl_status_t uic_mqtt_dotdot_level_min_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_max_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7427,7 +7427,7 @@ sl_status_t uic_mqtt_dotdot_level_options_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7457,7 +7457,7 @@ sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7487,7 +7487,7 @@ sl_status_t uic_mqtt_dotdot_level_on_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7517,7 +7517,7 @@ sl_status_t uic_mqtt_dotdot_level_on_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_off_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7547,7 +7547,7 @@ sl_status_t uic_mqtt_dotdot_level_off_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_default_move_rate_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7577,7 +7577,7 @@ sl_status_t uic_mqtt_dotdot_level_default_move_rate_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_start_up_current_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7646,7 +7646,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_alarm_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t alarm_code, + +- uint16_t cluster_identifier ++ uint8_t cluster_identifier + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_alarm_callback_t)( +@@ -7655,7 +7655,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_alarm_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t alarm_code, + +- uint16_t cluster_identifier ++ uint8_t cluster_identifier + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_all_alarms_callback_t)( +@@ -7671,9 +7671,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_get_alarm_response_callback_t)( + + uint8_t alarm_code, + +- uint16_t cluster_identifier, ++ uint8_t cluster_identifier, + +- uint32_t time_stamp ++ int32_t time_stamp + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_get_alarm_callback_t)( +@@ -7688,7 +7688,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_alarm_log_callback_t)( + ); + + typedef struct { +- uint16_t alarm_count; ++ int16_t alarm_count; + } uic_mqtt_dotdot_alarms_state_t; + + typedef struct { +@@ -7717,7 +7717,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_force_read_attributes_callback_t)( + typedef struct { + uint8_t alarm_code; + +- uint16_t cluster_identifier; ++ uint8_t cluster_identifier; + } uic_mqtt_dotdot_alarms_command_reset_alarm_fields_t; + + /** +@@ -7726,7 +7726,7 @@ typedef struct { + typedef struct { + uint8_t alarm_code; + +- uint16_t cluster_identifier; ++ uint8_t cluster_identifier; + } uic_mqtt_dotdot_alarms_command_alarm_fields_t; + + /** +@@ -7737,9 +7737,9 @@ typedef struct { + + uint8_t alarm_code; + +- uint16_t cluster_identifier; ++ uint8_t cluster_identifier; + +- uint32_t time_stamp; ++ int32_t time_stamp; + } uic_mqtt_dotdot_alarms_command_get_alarm_response_fields_t; + + +@@ -8045,7 +8045,7 @@ void uic_mqtt_dotdot_clear_alarms_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_alarms_alarm_count_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8110,16 +8110,16 @@ void uic_mqtt_dotdot_alarms_publish_empty_supported_commands( + // Callback types used by the time cluster + + typedef struct { +- uint32_t time; ++ uint8_t time; + uint8_t time_status; + int32_t time_zone; +- uint32_t dst_start; +- uint32_t dst_end; ++ int32_t dst_start; ++ int32_t dst_end; + int32_t dst_shift; +- uint32_t standard_time; +- uint32_t local_time; +- uint32_t last_set_time; +- uint32_t valid_until_time; ++ int32_t standard_time; ++ int32_t local_time; ++ uint8_t last_set_time; ++ uint8_t valid_until_time; + } uic_mqtt_dotdot_time_state_t; + + typedef struct { +@@ -8214,7 +8214,7 @@ void uic_mqtt_dotdot_clear_time_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_time_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8304,7 +8304,7 @@ sl_status_t uic_mqtt_dotdot_time_time_zone_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_dst_start_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8334,7 +8334,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_start_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_dst_end_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8394,7 +8394,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_shift_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_standard_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8424,7 +8424,7 @@ sl_status_t uic_mqtt_dotdot_time_standard_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_local_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8454,7 +8454,7 @@ sl_status_t uic_mqtt_dotdot_time_local_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_last_set_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8484,7 +8484,7 @@ sl_status_t uic_mqtt_dotdot_time_last_set_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_valid_until_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8558,7 +8558,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_check_in_response_callback_t) + uic_mqtt_dotdot_callback_call_type_t call_type, + bool start_fast_polling, + +- uint16_t fast_poll_timeout ++ int16_t fast_poll_timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_fast_poll_stop_callback_t)( +@@ -8570,25 +8570,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_set_long_poll_interval_callba + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint32_t new_long_poll_interval ++ int32_t new_long_poll_interval + + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t new_short_poll_interval ++ int16_t new_short_poll_interval + + ); + + typedef struct { +- uint32_t check_in_interval; +- uint32_t long_poll_interval; +- uint16_t short_poll_interval; +- uint16_t fast_poll_timeout; +- uint32_t check_in_interval_min; +- uint32_t long_poll_interval_min; +- uint16_t fast_poll_timeout_max; ++ int32_t check_in_interval; ++ int32_t long_poll_interval; ++ int16_t short_poll_interval; ++ int16_t fast_poll_timeout; ++ int32_t check_in_interval_min; ++ int32_t long_poll_interval_min; ++ int16_t fast_poll_timeout_max; + } uic_mqtt_dotdot_poll_control_state_t; + + typedef struct { +@@ -8623,21 +8623,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_force_read_attributes_callbac + typedef struct { + bool start_fast_polling; + +- uint16_t fast_poll_timeout; ++ int16_t fast_poll_timeout; + } uic_mqtt_dotdot_poll_control_command_check_in_response_fields_t; + + /** + * @brief Command fields for PollControl/SetLongPollInterval + */ + typedef struct { +- uint32_t new_long_poll_interval; ++ int32_t new_long_poll_interval; + } uic_mqtt_dotdot_poll_control_command_set_long_poll_interval_fields_t; + + /** + * @brief Command fields for PollControl/SetShortPollInterval + */ + typedef struct { +- uint16_t new_short_poll_interval; ++ int16_t new_short_poll_interval; + } uic_mqtt_dotdot_poll_control_command_set_short_poll_interval_fields_t; + + +@@ -8903,7 +8903,7 @@ void uic_mqtt_dotdot_clear_poll_control_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8933,7 +8933,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8963,7 +8963,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8993,7 +8993,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9023,7 +9023,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9053,7 +9053,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9083,7 +9083,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9148,10 +9148,10 @@ void uic_mqtt_dotdot_poll_control_publish_empty_supported_commands( + // Callback types used by the shade_configuration cluster + + typedef struct { +- uint16_t physical_closed_limit; +- uint8_t motor_step_size; ++ int16_t physical_closed_limit; ++ int8_t motor_step_size; + uint8_t status; +- uint16_t closed_limit; ++ int16_t closed_limit; + uint8_t mode; + } uic_mqtt_dotdot_shade_configuration_state_t; + +@@ -9242,7 +9242,7 @@ void uic_mqtt_dotdot_clear_shade_configuration_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9272,7 +9272,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9332,7 +9332,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9429,7 +9429,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_lock_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_lock_door_response_callback_t)( +@@ -9443,7 +9443,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_door_response_callback_t)( +@@ -9457,7 +9457,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_toggle_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_toggle_response_callback_t)( +@@ -9471,9 +9471,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t timeout_in_seconds, ++ int16_t timeout_in_seconds, + +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_callback_t)( +@@ -9487,39 +9487,39 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_log_record_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t log_index ++ int16_t log_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_log_record_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t log_entryid, ++ int16_t log_entryid, + +- uint32_t timestamp, ++ int32_t timestamp, + + GetLogRecordResponseEventType event_type, + + DrlkOperEventSource source_operation_event, + +- uint8_t event_id_or_alarm_code, ++ int8_t event_id_or_alarm_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin ++ uint8_t pin + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- const char* pin ++ uint8_t pin + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_pin_code_response_callback_t)( +@@ -9533,27 +9533,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- const char* code ++ uint8_t code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_pin_code_response_callback_t)( +@@ -9579,7 +9579,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_status_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status + +@@ -9595,14 +9595,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_status_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_status_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status + +@@ -9611,19 +9611,19 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid, ++ uint8_t * userid, + + uint8_t days_mask, + +- uint8_t start_hour, ++ int8_t start_hour, + +- uint8_t start_minute, ++ int8_t start_minute, + +- uint8_t end_hour, ++ int8_t end_hour, + +- uint8_t end_minute ++ int8_t end_minute + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_callback_t)( +@@ -9637,39 +9637,39 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ int8_t scheduleid, + +- uint16_t userid, ++ int16_t userid, + + zclStatus status, + + uint8_t days_mask, + +- uint8_t start_hour, ++ int8_t start_hour, + +- uint8_t start_minute, ++ int8_t start_minute, + +- uint8_t end_hour, ++ int8_t end_hour, + +- uint8_t end_minute ++ int8_t end_minute + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_callback_t)( +@@ -9683,13 +9683,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid, ++ uint8_t * userid, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time ++ int32_t local_end_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_callback_t)( +@@ -9703,33 +9703,33 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ int8_t scheduleid, + +- uint16_t userid, ++ int16_t userid, + + zclStatus status, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time ++ int32_t local_end_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_callback_t)( +@@ -9743,11 +9743,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t holiday_scheduleid, ++ uint8_t * holiday_scheduleid, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time, ++ int32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -9763,20 +9763,20 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t holiday_scheduleid ++ uint8_t * holiday_scheduleid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t holiday_scheduleid, ++ int8_t holiday_scheduleid, + + zclStatus status, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time, ++ int32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -9785,7 +9785,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t holiday_scheduleid ++ uint8_t * holiday_scheduleid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_callback_t)( +@@ -9799,7 +9799,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_type_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkUserType user_type + +@@ -9815,14 +9815,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_type_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_type_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserType user_type + +@@ -9831,13 +9831,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- const char* rfid_code ++ uint8_t rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_rfid_code_response_callback_t)( +@@ -9851,27 +9851,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- const char* rfid_code ++ uint8_t rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t userid ++ uint8_t * userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_rfid_code_response_callback_t)( +@@ -9899,11 +9899,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + DataOperationTypeEnum operation_type, + +- uint16_t user_index, ++ int16_t user_index, + + const char* user_name, + +- uint32_t user_uniqueid, ++ int32_t user_uniqueid, + + DrlkSettableUserStatus user_status, + +@@ -9916,7 +9916,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t user_index ++ int16_t user_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_response_callback_t)( +@@ -9928,7 +9928,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t user_index ++ int16_t user_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_operating_event_notification_callback_t)( +@@ -9939,11 +9939,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_operating_event_notification_cal + + OperatingEventNotificationOperationEventCode operation_event_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin, ++ uint8_t pin, + +- uint32_t local_time, ++ int32_t local_time, + + const char* data + +@@ -9956,15 +9956,15 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_programming_event_notification_c + + ProgrammingEventNotificationProgramEventCode program_event_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin, ++ uint8_t pin, + + DrlkUserType user_type, + + DrlkUserStatus user_status, + +- uint32_t local_time, ++ int32_t local_time, + + const char* data + +@@ -9977,9 +9977,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_credential_callback_t)( + + CredentialStruct credential, + +- const char* credential_data, ++ uint8_t credential_data, + +- uint16_t user_index, ++ int16_t user_index, + + DrlkSettableUserStatus user_status, + +@@ -10014,7 +10014,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unbolt_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- const char* pin_code ++ uint8_t pin_code + + ); + +@@ -10023,27 +10023,27 @@ typedef struct { + uint8_t lock_type; + bool actuator_enabled; + uint8_t door_state; +- uint32_t door_open_events; +- uint32_t door_closed_events; +- uint16_t open_period; +- uint16_t number_of_log_records_supported; +- uint16_t number_of_total_users_supported; +- uint16_t number_of_pin_users_supported; +- uint16_t number_of_rfid_users_supported; +- uint8_t number_of_week_day_schedules_supported_per_user; +- uint8_t number_of_year_day_schedules_supported_per_user; +- uint8_t number_of_holiday_schedules_supported; +- uint8_t max_pin_code_length; +- uint8_t min_pin_code_length; +- uint8_t max_rfid_code_length; +- uint8_t min_rfid_code_length; ++ int32_t door_open_events; ++ int32_t door_closed_events; ++ int16_t open_period; ++ int16_t number_of_log_records_supported; ++ int16_t number_of_total_users_supported; ++ int16_t number_of_pin_users_supported; ++ int16_t number_of_rfid_users_supported; ++ int8_t number_of_week_day_schedules_supported_per_user; ++ int8_t number_of_year_day_schedules_supported_per_user; ++ int8_t number_of_holiday_schedules_supported; ++ int8_t max_pin_code_length; ++ int8_t min_pin_code_length; ++ int8_t max_rfid_code_length; ++ int8_t min_rfid_code_length; + uint8_t credential_rules_support; +- uint8_t number_of_credentials_supported_per_user; ++ int8_t number_of_credentials_supported_per_user; + bool enable_logging; + const char* language; +- uint8_t led_settings; +- uint32_t auto_relock_time; +- uint8_t sound_volume; ++ int8_t led_settings; ++ int32_t auto_relock_time; ++ int8_t sound_volume; + uint8_t operating_mode; + uint16_t supported_operating_modes; + uint16_t default_configuration_register; +@@ -10052,12 +10052,12 @@ typedef struct { + bool enable_inside_statusled; + bool enable_privacy_mode_button; + uint8_t local_programming_features; +- uint8_t wrong_code_entry_limit; +- uint8_t user_code_temporary_disable_time; ++ int8_t wrong_code_entry_limit; ++ int8_t user_code_temporary_disable_time; + bool send_pin_over_the_air; + bool require_pi_nfor_rf_operation; + uint8_t security_level; +- uint16_t expiring_user_timeout; ++ int16_t expiring_user_timeout; + uint16_t alarm_mask; + uint16_t keypad_operation_event_mask; + uint16_t rf_operation_event_mask; +@@ -10140,7 +10140,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_force_read_attributes_callback_t + * @brief Command fields for DoorLock/LockDoor + */ + typedef struct { +- const char* pin_or_rfid_code; ++ uint8_t pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_lock_door_fields_t; + + /** +@@ -10154,7 +10154,7 @@ typedef struct { + * @brief Command fields for DoorLock/UnlockDoor + */ + typedef struct { +- const char* pin_or_rfid_code; ++ uint8_t pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_unlock_door_fields_t; + + /** +@@ -10168,7 +10168,7 @@ typedef struct { + * @brief Command fields for DoorLock/Toggle + */ + typedef struct { +- const char* pin_or_rfid_code; ++ uint8_t pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_toggle_fields_t; + + /** +@@ -10182,9 +10182,9 @@ typedef struct { + * @brief Command fields for DoorLock/UnlockWithTimeout + */ + typedef struct { +- uint16_t timeout_in_seconds; ++ int16_t timeout_in_seconds; + +- const char* pin_or_rfid_code; ++ uint8_t pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_fields_t; + + /** +@@ -10198,39 +10198,39 @@ typedef struct { + * @brief Command fields for DoorLock/GetLogRecord + */ + typedef struct { +- uint16_t log_index; ++ int16_t log_index; + } uic_mqtt_dotdot_door_lock_command_get_log_record_fields_t; + + /** + * @brief Command fields for DoorLock/GetLogRecordResponse + */ + typedef struct { +- uint16_t log_entryid; ++ int16_t log_entryid; + +- uint32_t timestamp; ++ int32_t timestamp; + + GetLogRecordResponseEventType event_type; + + DrlkOperEventSource source_operation_event; + +- uint8_t event_id_or_alarm_code; ++ int8_t event_id_or_alarm_code; + +- uint16_t userid; ++ int16_t userid; + +- const char* pin; ++ uint8_t pin; + } uic_mqtt_dotdot_door_lock_command_get_log_record_response_fields_t; + + /** + * @brief Command fields for DoorLock/SetPINCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + + DrlkSettableUserStatus user_status; + + DrlkUserType user_type; + +- const char* pin; ++ uint8_t pin; + } uic_mqtt_dotdot_door_lock_command_set_pin_code_fields_t; + + /** +@@ -10244,27 +10244,27 @@ typedef struct { + * @brief Command fields for DoorLock/GetPINCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_pin_code_fields_t; + + /** + * @brief Command fields for DoorLock/GetPINCodeResponse + */ + typedef struct { +- uint16_t userid; ++ int16_t userid; + + DrlkUserStatus user_status; + + DrlkUserType user_type; + +- const char* code; ++ uint8_t code; + } uic_mqtt_dotdot_door_lock_command_get_pin_code_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearPINCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_clear_pin_code_fields_t; + + /** +@@ -10285,7 +10285,7 @@ typedef struct { + * @brief Command fields for DoorLock/SetUserStatus + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + + DrlkSettableUserStatus user_status; + } uic_mqtt_dotdot_door_lock_command_set_user_status_fields_t; +@@ -10301,14 +10301,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUserStatus + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_user_status_fields_t; + + /** + * @brief Command fields for DoorLock/GetUserStatusResponse + */ + typedef struct { +- uint16_t userid; ++ int16_t userid; + + DrlkUserStatus user_status; + } uic_mqtt_dotdot_door_lock_command_get_user_status_response_fields_t; +@@ -10317,19 +10317,19 @@ typedef struct { + * @brief Command fields for DoorLock/SetWeekdaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + + uint8_t days_mask; + +- uint8_t start_hour; ++ int8_t start_hour; + +- uint8_t start_minute; ++ int8_t start_minute; + +- uint8_t end_hour; ++ int8_t end_hour; + +- uint8_t end_minute; ++ int8_t end_minute; + } uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_fields_t; + + /** +@@ -10343,39 +10343,39 @@ typedef struct { + * @brief Command fields for DoorLock/GetWeekdaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetWeekdayScheduleResponse + */ + typedef struct { +- uint8_t scheduleid; ++ int8_t scheduleid; + +- uint16_t userid; ++ int16_t userid; + + zclStatus status; + + uint8_t days_mask; + +- uint8_t start_hour; ++ int8_t start_hour; + +- uint8_t start_minute; ++ int8_t start_minute; + +- uint8_t end_hour; ++ int8_t end_hour; + +- uint8_t end_minute; ++ int8_t end_minute; + } uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearWeekdaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_fields_t; + + /** +@@ -10389,13 +10389,13 @@ typedef struct { + * @brief Command fields for DoorLock/SetYearDaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + +- uint32_t local_start_time; ++ int32_t local_start_time; + +- uint32_t local_end_time; ++ int32_t local_end_time; + } uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_fields_t; + + /** +@@ -10409,33 +10409,33 @@ typedef struct { + * @brief Command fields for DoorLock/GetYearDaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetYearDayScheduleResponse + */ + typedef struct { +- uint8_t scheduleid; ++ int8_t scheduleid; + +- uint16_t userid; ++ int16_t userid; + + zclStatus status; + +- uint32_t local_start_time; ++ int32_t local_start_time; + +- uint32_t local_end_time; ++ int32_t local_end_time; + } uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearYearDaySchedule + */ + typedef struct { +- uint8_t scheduleid; ++ uint8_t * scheduleid; + +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_fields_t; + + /** +@@ -10449,11 +10449,11 @@ typedef struct { + * @brief Command fields for DoorLock/SetHolidaySchedule + */ + typedef struct { +- uint8_t holiday_scheduleid; ++ uint8_t * holiday_scheduleid; + +- uint32_t local_start_time; ++ int32_t local_start_time; + +- uint32_t local_end_time; ++ int32_t local_end_time; + + DrlkOperMode operating_mode_during_holiday; + } uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_fields_t; +@@ -10469,20 +10469,20 @@ typedef struct { + * @brief Command fields for DoorLock/GetHolidaySchedule + */ + typedef struct { +- uint8_t holiday_scheduleid; ++ uint8_t * holiday_scheduleid; + } uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetHolidayScheduleResponse + */ + typedef struct { +- uint8_t holiday_scheduleid; ++ int8_t holiday_scheduleid; + + zclStatus status; + +- uint32_t local_start_time; ++ int32_t local_start_time; + +- uint32_t local_end_time; ++ int32_t local_end_time; + + DrlkOperMode operating_mode_during_holiday; + } uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_response_fields_t; +@@ -10491,7 +10491,7 @@ typedef struct { + * @brief Command fields for DoorLock/ClearHolidaySchedule + */ + typedef struct { +- uint8_t holiday_scheduleid; ++ uint8_t * holiday_scheduleid; + } uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_fields_t; + + /** +@@ -10505,7 +10505,7 @@ typedef struct { + * @brief Command fields for DoorLock/SetUserType + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + + DrlkUserType user_type; + } uic_mqtt_dotdot_door_lock_command_set_user_type_fields_t; +@@ -10521,14 +10521,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUserType + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_user_type_fields_t; + + /** + * @brief Command fields for DoorLock/GetUserTypeResponse + */ + typedef struct { +- uint16_t userid; ++ int16_t userid; + + DrlkUserType user_type; + } uic_mqtt_dotdot_door_lock_command_get_user_type_response_fields_t; +@@ -10537,13 +10537,13 @@ typedef struct { + * @brief Command fields for DoorLock/SetRFIDCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + + DrlkSettableUserStatus user_status; + + DrlkUserType user_type; + +- const char* rfid_code; ++ uint8_t rfid_code; + } uic_mqtt_dotdot_door_lock_command_set_rfid_code_fields_t; + + /** +@@ -10557,27 +10557,27 @@ typedef struct { + * @brief Command fields for DoorLock/GetRFIDCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_get_rfid_code_fields_t; + + /** + * @brief Command fields for DoorLock/GetRFIDCodeResponse + */ + typedef struct { +- uint16_t userid; ++ int16_t userid; + + DrlkUserStatus user_status; + + DrlkUserType user_type; + +- const char* rfid_code; ++ uint8_t rfid_code; + } uic_mqtt_dotdot_door_lock_command_get_rfid_code_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearRFIDCode + */ + typedef struct { +- uint16_t userid; ++ uint8_t * userid; + } uic_mqtt_dotdot_door_lock_command_clear_rfid_code_fields_t; + + /** +@@ -10600,11 +10600,11 @@ typedef struct { + typedef struct { + DataOperationTypeEnum operation_type; + +- uint16_t user_index; ++ int16_t user_index; + + const char* user_name; + +- uint32_t user_uniqueid; ++ int32_t user_uniqueid; + + DrlkSettableUserStatus user_status; + +@@ -10617,14 +10617,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUser + */ + typedef struct { +- uint16_t user_index; ++ int16_t user_index; + } uic_mqtt_dotdot_door_lock_command_get_user_fields_t; + + /** + * @brief Command fields for DoorLock/ClearUser + */ + typedef struct { +- uint16_t user_index; ++ int16_t user_index; + } uic_mqtt_dotdot_door_lock_command_clear_user_fields_t; + + /** +@@ -10635,11 +10635,11 @@ typedef struct { + + OperatingEventNotificationOperationEventCode operation_event_code; + +- uint16_t userid; ++ int16_t userid; + +- const char* pin; ++ uint8_t pin; + +- uint32_t local_time; ++ int32_t local_time; + + const char* data; + } uic_mqtt_dotdot_door_lock_command_operating_event_notification_fields_t; +@@ -10652,15 +10652,15 @@ typedef struct { + + ProgrammingEventNotificationProgramEventCode program_event_code; + +- uint16_t userid; ++ int16_t userid; + +- const char* pin; ++ uint8_t pin; + + DrlkUserType user_type; + + DrlkUserStatus user_status; + +- uint32_t local_time; ++ int32_t local_time; + + const char* data; + } uic_mqtt_dotdot_door_lock_command_programming_event_notification_fields_t; +@@ -10673,9 +10673,9 @@ typedef struct { + + CredentialStruct credential; + +- const char* credential_data; ++ uint8_t credential_data; + +- uint16_t user_index; ++ int16_t user_index; + + DrlkSettableUserStatus user_status; + +@@ -10700,7 +10700,7 @@ typedef struct { + * @brief Command fields for DoorLock/UnboltDoor + */ + typedef struct { +- const char* pin_code; ++ uint8_t pin_code; + } uic_mqtt_dotdot_door_lock_command_unbolt_door_fields_t; + + +@@ -13446,7 +13446,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13476,7 +13476,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13506,7 +13506,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_open_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13536,7 +13536,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_open_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13566,7 +13566,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13596,7 +13596,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13626,7 +13626,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13656,7 +13656,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13686,7 +13686,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13716,7 +13716,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13746,7 +13746,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_unre + */ + sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13776,7 +13776,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13806,7 +13806,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13836,7 +13836,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13896,7 +13896,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_credential_rules_support_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13986,7 +13986,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_language_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_led_settings_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14016,7 +14016,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_led_settings_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14046,7 +14046,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_sound_volume_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14316,7 +14316,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_local_programming_features_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14346,7 +14346,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14466,7 +14466,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_security_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14818,52 +14818,52 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t lift_value ++ int16_t lift_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t percentage_lift_value ++ int8_t percentage_lift_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t tilt_value ++ int16_t tilt_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t percentage_tilt_value ++ int8_t percentage_tilt_value + + ); + + typedef struct { + uint8_t window_covering_type; +- uint16_t physical_closed_limit_lift; +- uint16_t physical_closed_limit_tilt; +- uint16_t current_position_lift; +- uint16_t current_position_tilt; +- uint16_t number_of_actuations_lift; +- uint16_t number_of_actuations_tilt; ++ int16_t physical_closed_limit_lift; ++ int16_t physical_closed_limit_tilt; ++ int16_t current_position_lift; ++ int16_t current_position_tilt; ++ int16_t number_of_actuations_lift; ++ int16_t number_of_actuations_tilt; + uint8_t config_or_status; +- uint8_t current_position_lift_percentage; +- uint8_t current_position_tilt_percentage; +- uint16_t installed_open_limit_lift; +- uint16_t installed_closed_limit_lift; +- uint16_t installed_open_limit_tilt; +- uint16_t installed_closed_limit_tilt; +- uint16_t velocity_lift; +- uint16_t acceleration_time_lift; +- uint16_t deceleration_time_lift; ++ int8_t current_position_lift_percentage; ++ int8_t current_position_tilt_percentage; ++ int16_t installed_open_limit_lift; ++ int16_t installed_closed_limit_lift; ++ int16_t installed_open_limit_tilt; ++ int16_t installed_closed_limit_tilt; ++ int16_t velocity_lift; ++ int16_t acceleration_time_lift; ++ int16_t deceleration_time_lift; + uint8_t mode; +- const char* intermediate_setpoints_lift; +- const char* intermediate_setpoints_tilt; ++ uint8_t intermediate_setpoints_lift; ++ uint8_t intermediate_setpoints_tilt; + } uic_mqtt_dotdot_window_covering_state_t; + + typedef struct { +@@ -14909,28 +14909,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_force_read_attributes_call + * @brief Command fields for WindowCovering/GoToLiftValue + */ + typedef struct { +- uint16_t lift_value; ++ int16_t lift_value; + } uic_mqtt_dotdot_window_covering_command_go_to_lift_value_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToLiftPercentage + */ + typedef struct { +- uint8_t percentage_lift_value; ++ int8_t percentage_lift_value; + } uic_mqtt_dotdot_window_covering_command_go_to_lift_percentage_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToTiltValue + */ + typedef struct { +- uint16_t tilt_value; ++ int16_t tilt_value; + } uic_mqtt_dotdot_window_covering_command_go_to_tilt_value_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToTiltPercentage + */ + typedef struct { +- uint8_t percentage_tilt_value; ++ int8_t percentage_tilt_value; + } uic_mqtt_dotdot_window_covering_command_go_to_tilt_percentage_fields_t; + + +@@ -15306,7 +15306,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_window_covering_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15336,7 +15336,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15366,7 +15366,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15396,7 +15396,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15426,7 +15426,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15456,7 +15456,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15516,7 +15516,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_config_or_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15546,7 +15546,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_unr + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15576,7 +15576,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_unr + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15606,7 +15606,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15636,7 +15636,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15666,7 +15666,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15696,7 +15696,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15726,7 +15726,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15756,7 +15756,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15816,7 +15816,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15846,7 +15846,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15913,7 +15913,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_go_to_percent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t percent_open ++ int8_t percent_open + + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_stop_callback_t)( +@@ -15926,13 +15926,13 @@ typedef struct { + uint8_t moving_state; + uint16_t safety_status; + uint8_t capabilities; +- uint16_t open_events; +- uint16_t close_events; +- uint16_t command_open_events; +- uint16_t command_close_events; +- uint16_t open_period; +- uint16_t close_period; +- uint8_t barrier_position; ++ int16_t open_events; ++ int16_t close_events; ++ int16_t command_open_events; ++ int16_t command_close_events; ++ int16_t open_period; ++ int16_t close_period; ++ int8_t barrier_position; + } uic_mqtt_dotdot_barrier_control_state_t; + + typedef struct { +@@ -15968,7 +15968,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_force_read_attributes_call + * @brief Command fields for BarrierControl/GoToPercent + */ + typedef struct { +- uint8_t percent_open; ++ int8_t percent_open; + } uic_mqtt_dotdot_barrier_control_command_go_to_percent_fields_t; + + +@@ -16204,7 +16204,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_capabilities_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_open_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16234,7 +16234,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_close_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16264,7 +16264,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16294,7 +16294,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16324,7 +16324,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_open_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16354,7 +16354,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_close_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16384,7 +16384,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_barrier_position_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16450,26 +16450,26 @@ void uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands( + + typedef struct { + int16_t max_pressure; +- uint16_t max_speed; +- uint16_t max_flow; ++ int16_t max_speed; ++ int16_t max_flow; + int16_t min_const_pressure; + int16_t max_const_pressure; + int16_t min_comp_pressure; + int16_t max_comp_pressure; +- uint16_t min_const_speed; +- uint16_t max_const_speed; +- uint16_t min_const_flow; +- uint16_t max_const_flow; ++ int16_t min_const_speed; ++ int16_t max_const_speed; ++ int16_t min_const_flow; ++ int16_t max_const_flow; + int16_t min_const_temp; + int16_t max_const_temp; + uint16_t pump_status; + uint8_t effective_operation_mode; + uint8_t effective_control_mode; + int16_t capacity; +- uint16_t speed; +- uint32_t lifetime_running_hours; +- uint32_t power; +- uint32_t lifetime_energy_consumed; ++ int16_t speed; ++ int32_t lifetime_running_hours; ++ int32_t power; ++ int32_t lifetime_energy_consumed; + uint8_t operation_mode; + uint8_t control_mode; + uint16_t alarm_mask; +@@ -16611,7 +16611,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_pressure_unretain + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16641,7 +16641,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16791,7 +16791,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_comp_pressure_unr + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16821,7 +16821,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_unret + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16851,7 +16851,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_unret + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16881,7 +16881,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_unreta + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17091,7 +17091,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_capacity_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17121,7 +17121,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17151,7 +17151,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hour + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17181,7 +17181,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17375,17 +17375,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_get_relay_status_log_response_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t time_of_day, ++ int16_t time_of_day, + + uint8_t relay_status, + + int16_t local_temperature, + +- uint8_t humidity_percentage, ++ int8_t humidity_percentage, + + int16_t set_point, + +- uint16_t unread_entries ++ int16_t unread_entries + + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_get_weekly_schedule_callback_t)( +@@ -17416,8 +17416,8 @@ typedef struct { + int16_t abs_max_heat_setpoint_limit; + int16_t abs_min_cool_setpoint_limit; + int16_t abs_max_cool_setpoint_limit; +- uint8_t pi_cooling_demand; +- uint8_t pi_heating_demand; ++ int8_t pi_cooling_demand; ++ int8_t pi_heating_demand; + uint8_t hvac_system_type_configuration; + int8_t local_temperature_calibration; + int16_t occupied_cooling_setpoint; +@@ -17435,24 +17435,24 @@ typedef struct { + uint8_t alarm_mask; + uint8_t thermostat_running_mode; + uint8_t start_of_week; +- uint8_t number_of_weekly_transitions; +- uint8_t number_of_daily_transitions; ++ int8_t number_of_weekly_transitions; ++ int8_t number_of_daily_transitions; + uint8_t temperature_setpoint_hold; +- uint16_t temperature_setpoint_hold_duration; ++ int16_t temperature_setpoint_hold_duration; + uint8_t thermostat_programming_operation_mode; + uint16_t thermostat_running_state; + uint8_t setpoint_change_source; + int16_t setpoint_change_amount; +- uint32_t setpoint_change_source_timestamp; +- uint8_t occupied_setback; +- uint8_t occupied_setback_min; +- uint8_t occupied_setback_max; +- uint8_t unoccupied_setback; +- uint8_t unoccupied_setback_min; +- uint8_t unoccupied_setback_max; +- uint8_t emergency_heat_delta; ++ uint8_t setpoint_change_source_timestamp; ++ int8_t occupied_setback; ++ int8_t occupied_setback_min; ++ int8_t occupied_setback_max; ++ int8_t unoccupied_setback; ++ int8_t unoccupied_setback_min; ++ int8_t unoccupied_setback_max; ++ int8_t emergency_heat_delta; + uint8_t ac_type; +- uint16_t ac_capacity; ++ int16_t ac_capacity; + uint8_t ac_refrigerant_type; + uint8_t ac_compressor_type; + uint32_t ac_error_code; +@@ -17571,17 +17571,17 @@ typedef struct { + * @brief Command fields for Thermostat/GetRelayStatusLogResponse + */ + typedef struct { +- uint16_t time_of_day; ++ int16_t time_of_day; + + uint8_t relay_status; + + int16_t local_temperature; + +- uint8_t humidity_percentage; ++ int8_t humidity_percentage; + + int16_t set_point; + +- uint16_t unread_entries; ++ int16_t unread_entries; + } uic_mqtt_dotdot_thermostat_command_get_relay_status_log_response_fields_t; + + /** +@@ -18146,7 +18146,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_abs_max_cool_setpoint_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18176,7 +18176,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18716,7 +18716,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_start_of_week_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18746,7 +18746,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18806,7 +18806,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18956,7 +18956,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_amount_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18986,7 +18986,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_unretain + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19016,7 +19016,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19046,7 +19046,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19076,7 +19076,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19106,7 +19106,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19136,7 +19136,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19166,7 +19166,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19226,7 +19226,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_ac_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_ac_capacity_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19654,13 +19654,13 @@ void uic_mqtt_dotdot_fan_control_publish_empty_supported_commands( + // Callback types used by the dehumidification_control cluster + + typedef struct { +- uint8_t relative_humidity; +- uint8_t dehumidification_cooling; +- uint8_t rh_dehumidification_setpoint; ++ int8_t relative_humidity; ++ int8_t dehumidification_cooling; ++ int8_t rh_dehumidification_setpoint; + uint8_t relative_humidity_mode; + uint8_t dehumidification_lockout; +- uint8_t dehumidification_hysteresis; +- uint8_t dehumidification_max_cool; ++ int8_t dehumidification_hysteresis; ++ int8_t dehumidification_max_cool; + uint8_t relative_humidity_display; + } uic_mqtt_dotdot_dehumidification_control_state_t; + +@@ -19754,7 +19754,7 @@ void uic_mqtt_dotdot_clear_dehumidification_control_force_read_attributes_callba + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19784,7 +19784,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_unretain( + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19814,7 +19814,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_un + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19904,7 +19904,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_lockout_un + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19934,7 +19934,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -20246,11 +20246,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t hue, ++ int8_t hue, + + CCDirection direction, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20263,7 +20263,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_hue_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -20276,9 +20276,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_hue_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint8_t transition_time, ++ int8_t transition_time, + + uint8_t options_mask, + +@@ -20289,9 +20289,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_saturation_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20304,7 +20304,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_saturation_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -20317,9 +20317,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_saturation_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint8_t transition_time, ++ int8_t transition_time, + + uint8_t options_mask, + +@@ -20330,11 +20330,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t hue, ++ int8_t hue, + +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20345,11 +20345,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_color_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t colorx, ++ int16_t colorx, + +- uint16_t colory, ++ int16_t colory, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20377,7 +20377,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_callback_t)( + + int16_t stepy, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20388,9 +20388,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_color_temperature_ca + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t color_temperature_mireds, ++ int16_t color_temperature_mireds, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20401,11 +20401,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t enhanced_hue, ++ int16_t enhanced_hue, + + CCDirection direction, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20418,7 +20418,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_hue_callback_t + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- uint16_t rate, ++ int16_t rate, + + uint8_t options_mask, + +@@ -20431,9 +20431,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_step_hue_callback_t + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- uint16_t step_size, ++ int16_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20444,11 +20444,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_sat + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t enhanced_hue, ++ int16_t enhanced_hue, + +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -20465,9 +20465,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_color_loop_set_callback_t)( + + CCColorLoopDirection direction, + +- uint16_t time, ++ int16_t time, + +- uint16_t start_hue, ++ int16_t start_hue, + + uint8_t options_mask, + +@@ -20489,11 +20489,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_color_temperature_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- uint16_t rate, ++ int16_t rate, + +- uint16_t color_temperature_minimum_mireds, ++ uint8_t * color_temperature_minimum_mireds, + +- uint16_t color_temperature_maximum_mireds, ++ uint8_t * color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -20506,13 +20506,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_temperature_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- uint16_t step_size, ++ int16_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + +- uint16_t color_temperature_minimum_mireds, ++ uint8_t * color_temperature_minimum_mireds, + +- uint16_t color_temperature_maximum_mireds, ++ uint8_t * color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -20521,58 +20521,58 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_temperature_callb + ); + + typedef struct { +- uint8_t current_hue; +- uint8_t current_saturation; +- uint16_t remaining_time; +- uint16_t currentx; +- uint16_t currenty; ++ int8_t current_hue; ++ int8_t current_saturation; ++ int16_t remaining_time; ++ int16_t currentx; ++ int16_t currenty; + uint8_t drift_compensation; + const char* compensation_text; +- uint16_t color_temperature_mireds; ++ int16_t color_temperature_mireds; + uint8_t color_mode; + uint8_t options; +- uint8_t number_of_primaries; +- uint16_t primary1x; +- uint16_t primary1y; +- uint8_t primary1_intensity; +- uint16_t primary2x; +- uint16_t primary2y; +- uint8_t primary2_intensity; +- uint16_t primary3x; +- uint16_t primary3y; +- uint8_t primary3_intensity; +- uint16_t primary4x; +- uint16_t primary4y; +- uint8_t primary4_intensity; +- uint16_t primary5x; +- uint16_t primary5y; +- uint8_t primary5_intensity; +- uint16_t primary6x; +- uint16_t primary6y; +- uint8_t primary6_intensity; +- uint16_t white_pointx; +- uint16_t white_pointy; +- uint16_t color_pointrx; +- uint16_t color_pointry; +- uint8_t color_pointr_intensity; +- uint16_t color_pointgx; +- uint16_t color_pointgy; +- uint8_t color_pointg_intensity; +- uint16_t color_pointbx; +- uint16_t color_pointby; +- uint8_t color_pointb_intensity; +- uint16_t enhanced_current_hue; ++ int8_t number_of_primaries; ++ int16_t primary1x; ++ int16_t primary1y; ++ int8_t primary1_intensity; ++ int16_t primary2x; ++ int16_t primary2y; ++ int8_t primary2_intensity; ++ int16_t primary3x; ++ int16_t primary3y; ++ int8_t primary3_intensity; ++ int16_t primary4x; ++ int16_t primary4y; ++ int8_t primary4_intensity; ++ int16_t primary5x; ++ int16_t primary5y; ++ int8_t primary5_intensity; ++ int16_t primary6x; ++ int16_t primary6y; ++ int8_t primary6_intensity; ++ int16_t white_pointx; ++ int16_t white_pointy; ++ int16_t color_pointrx; ++ int16_t color_pointry; ++ int8_t color_pointr_intensity; ++ int16_t color_pointgx; ++ int16_t color_pointgy; ++ int8_t color_pointg_intensity; ++ int16_t color_pointbx; ++ int16_t color_pointby; ++ int8_t color_pointb_intensity; ++ int16_t enhanced_current_hue; + uint8_t enhanced_color_mode; +- uint8_t color_loop_active; +- uint8_t color_loop_direction; +- uint16_t color_loop_time; +- uint16_t color_loop_start_enhanced_hue; +- uint16_t color_loop_stored_enhanced_hue; ++ int8_t color_loop_active; ++ int8_t color_loop_direction; ++ int16_t color_loop_time; ++ int16_t color_loop_start_enhanced_hue; ++ int16_t color_loop_stored_enhanced_hue; + uint16_t color_capabilities; +- uint16_t color_temp_physical_min_mireds; +- uint16_t color_temp_physical_max_mireds; +- uint16_t couple_color_temp_to_level_min_mireds; +- uint16_t start_up_color_temperature_mireds; ++ int16_t color_temp_physical_min_mireds; ++ int16_t color_temp_physical_max_mireds; ++ int16_t couple_color_temp_to_level_min_mireds; ++ int16_t start_up_color_temperature_mireds; + } uic_mqtt_dotdot_color_control_state_t; + + typedef struct { +@@ -20650,11 +20650,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_force_read_attributes_callba + * @brief Command fields for ColorControl/MoveToHue + */ + typedef struct { +- uint8_t hue; ++ int8_t hue; + + CCDirection direction; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20667,7 +20667,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- uint8_t rate; ++ int8_t rate; + + uint8_t options_mask; + +@@ -20680,9 +20680,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- uint8_t step_size; ++ int8_t step_size; + +- uint8_t transition_time; ++ int8_t transition_time; + + uint8_t options_mask; + +@@ -20693,9 +20693,9 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToSaturation + */ + typedef struct { +- uint8_t saturation; ++ int8_t saturation; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20708,7 +20708,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- uint8_t rate; ++ int8_t rate; + + uint8_t options_mask; + +@@ -20721,9 +20721,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- uint8_t step_size; ++ int8_t step_size; + +- uint8_t transition_time; ++ int8_t transition_time; + + uint8_t options_mask; + +@@ -20734,11 +20734,11 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToHueAndSaturation + */ + typedef struct { +- uint8_t hue; ++ int8_t hue; + +- uint8_t saturation; ++ int8_t saturation; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20749,11 +20749,11 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToColor + */ + typedef struct { +- uint16_t colorx; ++ int16_t colorx; + +- uint16_t colory; ++ int16_t colory; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20781,7 +20781,7 @@ typedef struct { + + int16_t stepy; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20792,9 +20792,9 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToColorTemperature + */ + typedef struct { +- uint16_t color_temperature_mireds; ++ int16_t color_temperature_mireds; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20805,11 +20805,11 @@ typedef struct { + * @brief Command fields for ColorControl/EnhancedMoveToHue + */ + typedef struct { +- uint16_t enhanced_hue; ++ int16_t enhanced_hue; + + CCDirection direction; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20822,7 +20822,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- uint16_t rate; ++ int16_t rate; + + uint8_t options_mask; + +@@ -20835,9 +20835,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- uint16_t step_size; ++ int16_t step_size; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20848,11 +20848,11 @@ typedef struct { + * @brief Command fields for ColorControl/EnhancedMoveToHueAndSaturation + */ + typedef struct { +- uint16_t enhanced_hue; ++ int16_t enhanced_hue; + +- uint8_t saturation; ++ int8_t saturation; + +- uint16_t transition_time; ++ int16_t transition_time; + + uint8_t options_mask; + +@@ -20869,9 +20869,9 @@ typedef struct { + + CCColorLoopDirection direction; + +- uint16_t time; ++ int16_t time; + +- uint16_t start_hue; ++ int16_t start_hue; + + uint8_t options_mask; + +@@ -20893,11 +20893,11 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- uint16_t rate; ++ int16_t rate; + +- uint16_t color_temperature_minimum_mireds; ++ uint8_t * color_temperature_minimum_mireds; + +- uint16_t color_temperature_maximum_mireds; ++ uint8_t * color_temperature_maximum_mireds; + + uint8_t options_mask; + +@@ -20910,13 +20910,13 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- uint16_t step_size; ++ int16_t step_size; + +- uint16_t transition_time; ++ int16_t transition_time; + +- uint16_t color_temperature_minimum_mireds; ++ uint8_t * color_temperature_minimum_mireds; + +- uint16_t color_temperature_maximum_mireds; ++ uint8_t * color_temperature_maximum_mireds; + + uint8_t options_mask; + +@@ -21746,7 +21746,7 @@ void uic_mqtt_dotdot_clear_color_control_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_color_control_current_hue_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21776,7 +21776,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_hue_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_current_saturation_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21806,7 +21806,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_saturation_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_remaining_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21836,7 +21836,7 @@ sl_status_t uic_mqtt_dotdot_color_control_remaining_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_currentx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21866,7 +21866,7 @@ sl_status_t uic_mqtt_dotdot_color_control_currentx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_currenty_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21956,7 +21956,7 @@ sl_status_t uic_mqtt_dotdot_color_control_compensation_text_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22046,7 +22046,7 @@ sl_status_t uic_mqtt_dotdot_color_control_options_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22076,7 +22076,7 @@ sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22106,7 +22106,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22136,7 +22136,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22166,7 +22166,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22196,7 +22196,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22226,7 +22226,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22256,7 +22256,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22286,7 +22286,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22316,7 +22316,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22346,7 +22346,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22376,7 +22376,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22406,7 +22406,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22436,7 +22436,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22466,7 +22466,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22496,7 +22496,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22526,7 +22526,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22556,7 +22556,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22586,7 +22586,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22616,7 +22616,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_white_pointx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22646,7 +22646,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_white_pointy_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22676,7 +22676,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointy_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22706,7 +22706,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22736,7 +22736,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointry_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22766,7 +22766,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22796,7 +22796,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22826,7 +22826,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22856,7 +22856,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22886,7 +22886,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointby_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22916,7 +22916,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointby_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22946,7 +22946,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23006,7 +23006,7 @@ sl_status_t uic_mqtt_dotdot_color_control_enhanced_color_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23036,7 +23036,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23066,7 +23066,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23096,7 +23096,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23126,7 +23126,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_unretain + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23186,7 +23186,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_capabilities_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23216,7 +23216,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_unretai + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23246,7 +23246,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_unretai + */ + sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23276,7 +23276,7 @@ sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_ + */ + sl_status_t uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23341,22 +23341,22 @@ void uic_mqtt_dotdot_color_control_publish_empty_supported_commands( + // Callback types used by the ballast_configuration cluster + + typedef struct { +- uint8_t physical_min_level; +- uint8_t physical_max_level; ++ int8_t physical_min_level; ++ int8_t physical_max_level; + uint8_t ballast_status; +- uint8_t min_level; +- uint8_t max_level; +- uint8_t power_on_level; +- uint16_t power_on_fade_time; +- uint8_t intrinsic_ballast_factor; +- uint8_t ballast_factor_adjustment; +- uint8_t lamp_quantity; ++ int8_t min_level; ++ int8_t max_level; ++ int8_t power_on_level; ++ int16_t power_on_fade_time; ++ int8_t intrinsic_ballast_factor; ++ int8_t ballast_factor_adjustment; ++ int8_t lamp_quantity; + const char* lamp_type; + const char* lamp_manufacturer; +- uint32_t lamp_rated_hours; +- uint32_t lamp_burn_hours; ++ int32_t lamp_rated_hours; ++ int32_t lamp_burn_hours; + uint8_t lamp_alarm_mode; +- uint32_t lamp_burn_hours_trip_point; ++ int32_t lamp_burn_hours_trip_point; + } uic_mqtt_dotdot_ballast_configuration_state_t; + + typedef struct { +@@ -23457,7 +23457,7 @@ void uic_mqtt_dotdot_clear_ballast_configuration_force_read_attributes_callbacks + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23487,7 +23487,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23547,7 +23547,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23577,7 +23577,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23607,7 +23607,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23637,7 +23637,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23667,7 +23667,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23697,7 +23697,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_unret + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23727,7 +23727,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_unre + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23817,7 +23817,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_manufacturer_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23847,7 +23847,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23907,7 +23907,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_alarm_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23972,10 +23972,10 @@ void uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands( + // Callback types used by the illuminance_measurement cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + uint8_t light_sensor_type; + } uic_mqtt_dotdot_illuminance_measurement_state_t; + +@@ -24066,7 +24066,7 @@ void uic_mqtt_dotdot_clear_illuminance_measurement_force_read_attributes_callbac + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24096,7 +24096,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24126,7 +24126,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24156,7 +24156,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24253,7 +24253,7 @@ void uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands( + typedef struct { + uint8_t level_status; + uint8_t light_sensor_type; +- uint16_t illuminance_target_level; ++ int16_t illuminance_target_level; + } uic_mqtt_dotdot_illuminance_level_sensing_state_t; + + typedef struct { +@@ -24401,7 +24401,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_light_sensor_type_unretain + */ + sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24469,7 +24469,7 @@ typedef struct { + int16_t measured_value; + int16_t min_measured_value; + int16_t max_measured_value; +- uint16_t tolerance; ++ int16_t tolerance; + } uic_mqtt_dotdot_temperature_measurement_state_t; + + typedef struct { +@@ -24648,7 +24648,7 @@ sl_status_t uic_mqtt_dotdot_temperature_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24716,11 +24716,11 @@ typedef struct { + int16_t measured_value; + int16_t min_measured_value; + int16_t max_measured_value; +- uint16_t tolerance; ++ int16_t tolerance; + int16_t scaled_value; + int16_t min_scaled_value; + int16_t max_scaled_value; +- uint16_t scaled_tolerance; ++ int16_t scaled_tolerance; + int8_t scale; + } uic_mqtt_dotdot_pressure_measurement_state_t; + +@@ -24905,7 +24905,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25025,7 +25025,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_scaled_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25120,10 +25120,10 @@ void uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands( + // Callback types used by the flow_measurement cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_flow_measurement_state_t; + + typedef struct { +@@ -25212,7 +25212,7 @@ void uic_mqtt_dotdot_clear_flow_measurement_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25242,7 +25242,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25272,7 +25272,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25302,7 +25302,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25367,10 +25367,10 @@ void uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands( + // Callback types used by the relativity_humidity cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_relativity_humidity_state_t; + + typedef struct { +@@ -25459,7 +25459,7 @@ void uic_mqtt_dotdot_clear_relativity_humidity_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25489,7 +25489,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25519,7 +25519,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25549,7 +25549,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25617,15 +25617,15 @@ typedef struct { + uint8_t occupancy; + uint8_t occupancy_sensor_type; + uint8_t occupancy_sensor_type_bitmap; +- uint16_t pir_occupied_to_unoccupied_delay; +- uint16_t pir_unoccupied_to_occupied_delay; +- uint8_t pir_unoccupied_to_occupied_threshold; +- uint16_t ultrasonic_occupied_to_unoccupied_delay; +- uint16_t ultrasonic_unoccupied_to_occupied_delay; +- uint8_t ultrasonic_unoccupied_to_occupied_threshold; +- uint16_t physical_contact_occupied_to_unoccupied_delay; +- uint16_t physical_contact_unoccupied_to_occupied_delay; +- uint8_t physical_contact_unoccupied_to_occupied_threshold; ++ int16_t pir_occupied_to_unoccupied_delay; ++ int16_t pir_unoccupied_to_occupied_delay; ++ int8_t pir_unoccupied_to_occupied_threshold; ++ int16_t ultrasonic_occupied_to_unoccupied_delay; ++ int16_t ultrasonic_unoccupied_to_occupied_delay; ++ int8_t ultrasonic_unoccupied_to_occupied_threshold; ++ int16_t physical_contact_occupied_to_unoccupied_delay; ++ int16_t physical_contact_unoccupied_to_occupied_delay; ++ int8_t physical_contact_unoccupied_to_occupied_threshold; + } uic_mqtt_dotdot_occupancy_sensing_state_t; + + typedef struct { +@@ -25812,7 +25812,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_occupancy_sensor_type_bitmap_unret + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25842,7 +25842,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_u + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25872,7 +25872,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_u + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25902,7 +25902,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_thresho + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25932,7 +25932,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25962,7 +25962,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25992,7 +25992,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26022,7 +26022,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unocc + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26052,7 +26052,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26117,10 +26117,10 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands( + // Callback types used by the soil_moisture cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_soil_moisture_state_t; + + typedef struct { +@@ -26209,7 +26209,7 @@ void uic_mqtt_dotdot_clear_soil_moisture_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26239,7 +26239,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26269,7 +26269,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26299,7 +26299,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26364,10 +26364,10 @@ void uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands( + // Callback types used by the ph_measurement cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_ph_measurement_state_t; + + typedef struct { +@@ -26456,7 +26456,7 @@ void uic_mqtt_dotdot_clear_ph_measurement_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26486,7 +26486,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26516,7 +26516,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26546,7 +26546,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26611,10 +26611,10 @@ void uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands( + // Callback types used by the electrical_conductivity_measurement cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_electrical_conductivity_measurement_state_t; + + typedef struct { +@@ -26703,7 +26703,7 @@ void uic_mqtt_dotdot_clear_electrical_conductivity_measurement_force_read_attrib + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26733,7 +26733,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_u + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26763,7 +26763,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_val + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26793,7 +26793,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_val + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26858,10 +26858,10 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported + // Callback types used by the wind_speed_measurement cluster + + typedef struct { +- uint16_t measured_value; +- uint16_t min_measured_value; +- uint16_t max_measured_value; +- uint16_t tolerance; ++ int16_t measured_value; ++ int16_t min_measured_value; ++ int16_t max_measured_value; ++ int16_t tolerance; + } uic_mqtt_dotdot_wind_speed_measurement_state_t; + + typedef struct { +@@ -26950,7 +26950,7 @@ void uic_mqtt_dotdot_clear_wind_speed_measurement_force_read_attributes_callback + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26980,7 +26980,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27010,7 +27010,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27040,7 +27040,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27850,7 +27850,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + ZoneEnrollResponseEnrollResponseCode enroll_response_code, + +- uint8_t zoneid ++ int8_t zoneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback_t)( +@@ -27861,9 +27861,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_status_change_notification_c + + uint8_t extended_status, + +- uint8_t zoneid, ++ int8_t zoneid, + +- uint16_t delay ++ int16_t delay + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_callback_t)( +@@ -27877,16 +27877,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + IasZoneType zone_type, + +- uint16_t manufacturer_code ++ int16_t manufacturer_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t test_mode_duration, ++ int8_t test_mode_duration, + +- uint8_t current_zone_sensitivity_level ++ int8_t current_zone_sensitivity_level + + ); + +@@ -27895,9 +27895,9 @@ typedef struct { + uint8_t zone_type; + uint16_t zone_status; + uint64_t iascie_address; +- uint8_t zoneid; +- uint8_t number_of_zone_sensitivity_levels_supported; +- uint8_t current_zone_sensitivity_level; ++ int8_t zoneid; ++ int8_t number_of_zone_sensitivity_levels_supported; ++ int8_t current_zone_sensitivity_level; + } uic_mqtt_dotdot_ias_zone_state_t; + + typedef struct { +@@ -27932,7 +27932,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_force_read_attributes_callback_t) + typedef struct { + ZoneEnrollResponseEnrollResponseCode enroll_response_code; + +- uint8_t zoneid; ++ int8_t zoneid; + } uic_mqtt_dotdot_ias_zone_command_zone_enroll_response_fields_t; + + /** +@@ -27943,9 +27943,9 @@ typedef struct { + + uint8_t extended_status; + +- uint8_t zoneid; ++ int8_t zoneid; + +- uint16_t delay; ++ int16_t delay; + } uic_mqtt_dotdot_ias_zone_command_zone_status_change_notification_fields_t; + + /** +@@ -27954,16 +27954,16 @@ typedef struct { + typedef struct { + IasZoneType zone_type; + +- uint16_t manufacturer_code; ++ int16_t manufacturer_code; + } uic_mqtt_dotdot_ias_zone_command_zone_enroll_request_fields_t; + + /** + * @brief Command fields for IASZone/InitiateTestMode + */ + typedef struct { +- uint8_t test_mode_duration; ++ int8_t test_mode_duration; + +- uint8_t current_zone_sensitivity_level; ++ int8_t current_zone_sensitivity_level; + } uic_mqtt_dotdot_ias_zone_command_initiate_test_mode_fields_t; + + +@@ -28349,7 +28349,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_iascie_address_unretain( + */ + sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28379,7 +28379,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_unretain( + */ + sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28409,7 +28409,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported + */ + sl_status_t uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28478,9 +28478,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_start_warning_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t siren_configuration, + +- uint16_t warning_duration, ++ int16_t warning_duration, + +- uint8_t strobe_duty_cycle, ++ int8_t strobe_duty_cycle, + + IaswdLevel strobe_level + +@@ -28494,7 +28494,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_squawk_callback_t)( + ); + + typedef struct { +- uint16_t max_duration; ++ int16_t max_duration; + } uic_mqtt_dotdot_iaswd_state_t; + + typedef struct { +@@ -28523,9 +28523,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_force_read_attributes_callback_t)( + typedef struct { + uint8_t siren_configuration; + +- uint16_t warning_duration; ++ int16_t warning_duration; + +- uint8_t strobe_duty_cycle; ++ int8_t strobe_duty_cycle; + + IaswdLevel strobe_level; + } uic_mqtt_dotdot_iaswd_command_start_warning_fields_t; +@@ -28680,7 +28680,7 @@ void uic_mqtt_dotdot_clear_iaswd_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_iaswd_max_duration_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28745,23 +28745,23 @@ void uic_mqtt_dotdot_iaswd_publish_empty_supported_commands( + // Callback types used by the metering cluster + + typedef struct { +- uint64_t current_summation_delivered; +- uint64_t current_summation_received; +- uint64_t current_max_demand_delivered; ++ int64_t current_summation_delivered; ++ int64_t current_summation_received; ++ int64_t current_max_demand_delivered; + int8_t current_max_demand_received; + int8_t power_factor; +- uint32_t reading_snap_shot_time; +- uint32_t current_max_demand_delivered_time; +- uint32_t current_max_demand_received_time; +- uint8_t default_update_period; ++ uint8_t reading_snap_shot_time; ++ uint8_t current_max_demand_delivered_time; ++ uint8_t current_max_demand_received_time; ++ int8_t default_update_period; + uint8_t supply_status; +- uint64_t current_inlet_energy_carrier_summation; +- uint64_t current_outlet_energy_carrier_summation; ++ int64_t current_inlet_energy_carrier_summation; ++ int64_t current_outlet_energy_carrier_summation; + int32_t inlet_temperature; + int32_t outlet_temperature; + uint8_t unitof_measure; +- uint32_t multiplier; +- uint32_t divisor; ++ int32_t multiplier; ++ int32_t divisor; + uint8_t summation_formatting; + uint8_t demand_formatting; + uint8_t historical_consumption_formatting; +@@ -28881,7 +28881,7 @@ void uic_mqtt_dotdot_clear_metering_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28911,7 +28911,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_summation_received_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28941,7 +28941,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_received_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29031,7 +29031,7 @@ sl_status_t uic_mqtt_dotdot_metering_power_factor_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29061,7 +29061,7 @@ sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29091,7 +29091,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29121,7 +29121,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_default_update_period_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29181,7 +29181,7 @@ sl_status_t uic_mqtt_dotdot_metering_supply_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29211,7 +29211,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_unre + */ + sl_status_t uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29331,7 +29331,7 @@ sl_status_t uic_mqtt_dotdot_metering_unitof_measure_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_multiplier_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29361,7 +29361,7 @@ sl_status_t uic_mqtt_dotdot_metering_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_divisor_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29698,14 +29698,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_profile_info_re + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t profile_count, ++ int8_t profile_count, + + ProfileIntervalPeriod profile_interval_period, + +- uint8_t max_number_of_intervals, ++ int8_t max_number_of_intervals, + + uint8_t list_of_attributes_count, +- const uint16_t *list_of_attributes ++ const uint8_t *list_of_attributes + + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_profile_info_callback_t)( +@@ -29717,29 +29717,29 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_measurement_pro + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint32_t start_time, ++ uint8_t start_time, + + GetMeasurementProfileResponseStatus status, + + ProfileIntervalPeriod profile_interval_period, + +- uint8_t number_of_intervals_delivered, ++ int8_t number_of_intervals_delivered, + +- uint16_t attribute_id, ++ uint8_t attribute_id, + + uint8_t intervals_count, +- const uint8_t *intervals ++ const int8_t *intervals + + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t attributeid, ++ uint8_t attributeid, + +- uint32_t start_time, ++ uint8_t start_time, + +- uint8_t number_of_intervals ++ int8_t number_of_intervals + + ); + +@@ -29754,19 +29754,19 @@ typedef struct { + int16_t dc_power; + int16_t dc_power_min; + int16_t dc_power_max; +- uint16_t dc_voltage_multiplier; +- uint16_t dc_voltage_divisor; +- uint16_t dc_current_multiplier; +- uint16_t dc_current_divisor; +- uint16_t dc_power_multiplier; +- uint16_t dc_power_divisor; +- uint16_t ac_frequency; +- uint16_t ac_frequency_min; +- uint16_t ac_frequency_max; +- uint16_t neutral_current; ++ int16_t dc_voltage_multiplier; ++ int16_t dc_voltage_divisor; ++ int16_t dc_current_multiplier; ++ int16_t dc_current_divisor; ++ int16_t dc_power_multiplier; ++ int16_t dc_power_divisor; ++ int16_t ac_frequency; ++ int16_t ac_frequency_min; ++ int16_t ac_frequency_max; ++ int16_t neutral_current; + int32_t total_active_power; + int32_t total_reactive_power; +- uint32_t total_apparent_power; ++ int32_t total_apparent_power; + int16_t measured1st_harmonic_current; + int16_t measured3rd_harmonic_current; + int16_t measured5th_harmonic_current; +@@ -29779,40 +29779,40 @@ typedef struct { + int16_t measured_phase7th_harmonic_current; + int16_t measured_phase9th_harmonic_current; + int16_t measured_phase11th_harmonic_current; +- uint16_t ac_frequency_multiplier; +- uint16_t ac_frequency_divisor; +- uint32_t power_multiplier; +- uint32_t power_divisor; ++ int16_t ac_frequency_multiplier; ++ int16_t ac_frequency_divisor; ++ int32_t power_multiplier; ++ int32_t power_divisor; + int8_t harmonic_current_multiplier; + int8_t phase_harmonic_current_multiplier; +- uint16_t line_current; ++ int16_t line_current; + int16_t active_current; + int16_t reactive_current; +- uint16_t rms_voltage; +- uint16_t rms_voltage_min; +- uint16_t rms_voltage_max; +- uint16_t rms_current; +- uint16_t rms_current_min; +- uint16_t rms_current_max; ++ int16_t rms_voltage; ++ int16_t rms_voltage_min; ++ int16_t rms_voltage_max; ++ int16_t rms_current; ++ int16_t rms_current_min; ++ int16_t rms_current_max; + int16_t active_power; + int16_t active_power_min; + int16_t active_power_max; + int16_t reactive_power; +- uint16_t apparent_power; ++ int16_t apparent_power; + int8_t power_factor; +- uint16_t average_rms_voltage_measurement_period; +- uint16_t average_rms_over_voltage_counter; +- uint16_t average_rms_under_voltage_counter; +- uint16_t rms_extreme_over_voltage_period; +- uint16_t rms_extreme_under_voltage_period; +- uint16_t rms_voltage_sag_period; +- uint16_t rms_voltage_swell_period; +- uint16_t ac_voltage_multiplier; +- uint16_t ac_voltage_divisor; +- uint16_t ac_current_multiplier; +- uint16_t ac_current_divisor; +- uint16_t ac_power_multiplier; +- uint16_t ac_power_divisor; ++ int16_t average_rms_voltage_measurement_period; ++ int16_t average_rms_over_voltage_counter; ++ int16_t average_rms_under_voltage_counter; ++ int16_t rms_extreme_over_voltage_period; ++ int16_t rms_extreme_under_voltage_period; ++ int16_t rms_voltage_sag_period; ++ int16_t rms_voltage_swell_period; ++ int16_t ac_voltage_multiplier; ++ int16_t ac_voltage_divisor; ++ int16_t ac_current_multiplier; ++ int16_t ac_current_divisor; ++ int16_t ac_power_multiplier; ++ int16_t ac_power_divisor; + uint8_t dc_overload_alarms_mask; + int16_t dc_voltage_overload; + int16_t dc_current_overload; +@@ -29827,50 +29827,50 @@ typedef struct { + int16_t rms_extreme_under_voltage; + int16_t rms_voltage_sag; + int16_t rms_voltage_swell; +- uint16_t line_current_phb; ++ int16_t line_current_phb; + int16_t active_current_phb; + int16_t reactive_current_phb; +- uint16_t rms_voltage_phb; +- uint16_t rms_voltage_min_phb; +- uint16_t rms_voltage_max_phb; +- uint16_t rms_current_phb; +- uint16_t rms_current_min_phb; +- uint16_t rms_current_max_phb; ++ int16_t rms_voltage_phb; ++ int16_t rms_voltage_min_phb; ++ int16_t rms_voltage_max_phb; ++ int16_t rms_current_phb; ++ int16_t rms_current_min_phb; ++ int16_t rms_current_max_phb; + int16_t active_power_phb; + int16_t active_power_min_phb; + int16_t active_power_max_phb; + int16_t reactive_power_phb; +- uint16_t apparent_power_phb; ++ int16_t apparent_power_phb; + int8_t power_factor_phb; +- uint16_t average_rms_voltage_measurement_period_phb; +- uint16_t average_rms_over_voltage_counter_phb; +- uint16_t average_rms_under_voltage_counter_phb; +- uint16_t rms_extreme_over_voltage_period_phb; +- uint16_t rms_extreme_under_voltage_period_phb; +- uint16_t rms_voltage_sag_period_phb; +- uint16_t rms_voltage_swell_period_phb; +- uint16_t line_current_phc; ++ int16_t average_rms_voltage_measurement_period_phb; ++ int16_t average_rms_over_voltage_counter_phb; ++ int16_t average_rms_under_voltage_counter_phb; ++ int16_t rms_extreme_over_voltage_period_phb; ++ int16_t rms_extreme_under_voltage_period_phb; ++ int16_t rms_voltage_sag_period_phb; ++ int16_t rms_voltage_swell_period_phb; ++ int16_t line_current_phc; + int16_t active_current_phc; + int16_t reactive_current_phc; +- uint16_t rms_voltage_phc; +- uint16_t rms_voltage_min_phc; +- uint16_t rms_voltage_max_phc; +- uint16_t rms_current_phc; +- uint16_t rms_current_min_phc; +- uint16_t rms_current_max_phc; ++ int16_t rms_voltage_phc; ++ int16_t rms_voltage_min_phc; ++ int16_t rms_voltage_max_phc; ++ int16_t rms_current_phc; ++ int16_t rms_current_min_phc; ++ int16_t rms_current_max_phc; + int16_t active_power_phc; + int16_t active_power_min_phc; + int16_t active_power_max_phc; + int16_t reactive_power_phc; +- uint16_t apparent_power_phc; ++ int16_t apparent_power_phc; + int8_t power_factor_phc; +- uint16_t average_rms_voltage_measurement_period_phc; +- uint16_t average_rms_over_voltage_counter_phc; +- uint16_t average_rms_under_voltage_counter_phc; +- uint16_t rms_extreme_over_voltage_period_phc; +- uint16_t rms_extreme_under_voltage_period_phc; +- uint16_t rms_voltage_sag_period_phc; +- uint16_t rms_voltage_swell_period_phc; ++ int16_t average_rms_voltage_measurement_period_phc; ++ int16_t average_rms_over_voltage_counter_phc; ++ int16_t average_rms_under_voltage_counter_phc; ++ int16_t rms_extreme_over_voltage_period_phc; ++ int16_t rms_extreme_under_voltage_period_phc; ++ int16_t rms_voltage_sag_period_phc; ++ int16_t rms_voltage_swell_period_phc; + } uic_mqtt_dotdot_electrical_measurement_state_t; + + typedef struct { +@@ -30023,43 +30023,43 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_force_read_attribut + * @brief Command fields for ElectricalMeasurement/GetProfileInfoResponse + */ + typedef struct { +- uint8_t profile_count; ++ int8_t profile_count; + + ProfileIntervalPeriod profile_interval_period; + +- uint8_t max_number_of_intervals; ++ int8_t max_number_of_intervals; + + uint8_t list_of_attributes_count; +- const uint16_t *list_of_attributes; ++ const uint8_t *list_of_attributes; + } uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t; + + /** + * @brief Command fields for ElectricalMeasurement/GetMeasurementProfileResponse + */ + typedef struct { +- uint32_t start_time; ++ uint8_t start_time; + + GetMeasurementProfileResponseStatus status; + + ProfileIntervalPeriod profile_interval_period; + +- uint8_t number_of_intervals_delivered; ++ int8_t number_of_intervals_delivered; + +- uint16_t attribute_id; ++ uint8_t attribute_id; + + uint8_t intervals_count; +- const uint8_t *intervals; ++ const int8_t *intervals; + } uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t; + + /** + * @brief Command fields for ElectricalMeasurement/GetMeasurementProfile + */ + typedef struct { +- uint16_t attributeid; ++ uint8_t attributeid; + +- uint32_t start_time; ++ uint8_t start_time; + +- uint8_t number_of_intervals; ++ int8_t number_of_intervals; + } uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_fields_t; + + +@@ -30585,7 +30585,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30615,7 +30615,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30645,7 +30645,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30675,7 +30675,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30705,7 +30705,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30735,7 +30735,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30765,7 +30765,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30795,7 +30795,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30825,7 +30825,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30855,7 +30855,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30945,7 +30945,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_total_reactive_power_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31335,7 +31335,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_measured_phase11th_harmonic_c + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31365,7 +31365,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_unret + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31395,7 +31395,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31425,7 +31425,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31515,7 +31515,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_phase_harmonic_current_multip + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31605,7 +31605,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31635,7 +31635,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31665,7 +31665,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31695,7 +31695,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31725,7 +31725,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31755,7 +31755,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31905,7 +31905,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31965,7 +31965,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31995,7 +31995,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32025,7 +32025,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32055,7 +32055,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32085,7 +32085,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32115,7 +32115,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32145,7 +32145,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_unreta + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32175,7 +32175,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_unre + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32205,7 +32205,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32235,7 +32235,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32265,7 +32265,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32295,7 +32295,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32325,7 +32325,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32775,7 +32775,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32865,7 +32865,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phb_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32895,7 +32895,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32925,7 +32925,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32955,7 +32955,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32985,7 +32985,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33015,7 +33015,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33165,7 +33165,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33225,7 +33225,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33255,7 +33255,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33285,7 +33285,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33315,7 +33315,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33345,7 +33345,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33375,7 +33375,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33405,7 +33405,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_un + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33435,7 +33435,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_ + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33525,7 +33525,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phc_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33555,7 +33555,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33585,7 +33585,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33615,7 +33615,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33645,7 +33645,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33675,7 +33675,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33825,7 +33825,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33885,7 +33885,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33915,7 +33915,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33945,7 +33945,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33975,7 +33975,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34005,7 +34005,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34035,7 +34035,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34065,7 +34065,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_un + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34130,37 +34130,37 @@ void uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands( + // Callback types used by the diagnostics cluster + + typedef struct { +- uint16_t number_of_resets; +- uint16_t persistent_memory_writes; +- uint32_t mac_rx_bcast; +- uint32_t mac_tx_bcast; +- uint32_t mac_rx_ucast; +- uint32_t mac_tx_ucast; +- uint16_t mac_tx_ucast_retry; +- uint16_t mac_tx_ucast_fail; +- uint16_t aps_rx_bcast; +- uint16_t aps_tx_bcast; +- uint16_t aps_rx_ucast; +- uint16_t aps_tx_ucast_success; +- uint16_t aps_tx_ucast_retry; +- uint16_t aps_tx_ucast_fail; +- uint16_t route_disc_initiated; +- uint16_t neighbor_added; +- uint16_t neighbor_removed; +- uint16_t neighbor_stale; +- uint16_t join_indication; +- uint16_t child_moved; +- uint16_t nwkfc_failure; +- uint16_t apsfc_failure; +- uint16_t aps_unauthorized_key; +- uint16_t nwk_decrypt_failures; +- uint16_t aps_decrypt_failures; +- uint16_t packet_buffer_allocate_failures; +- uint16_t relayed_ucast; +- uint16_t phy_to_mac_queue_limit_reached; +- uint16_t packet_validate_drop_count; +- uint16_t average_mac_retry_per_aps_message_sent; +- uint8_t last_messagelqi; ++ int16_t number_of_resets; ++ int16_t persistent_memory_writes; ++ int32_t mac_rx_bcast; ++ int32_t mac_tx_bcast; ++ int32_t mac_rx_ucast; ++ int32_t mac_tx_ucast; ++ int16_t mac_tx_ucast_retry; ++ int16_t mac_tx_ucast_fail; ++ int16_t aps_rx_bcast; ++ int16_t aps_tx_bcast; ++ int16_t aps_rx_ucast; ++ int16_t aps_tx_ucast_success; ++ int16_t aps_tx_ucast_retry; ++ int16_t aps_tx_ucast_fail; ++ int16_t route_disc_initiated; ++ int16_t neighbor_added; ++ int16_t neighbor_removed; ++ int16_t neighbor_stale; ++ int16_t join_indication; ++ int16_t child_moved; ++ int16_t nwkfc_failure; ++ int16_t apsfc_failure; ++ int16_t aps_unauthorized_key; ++ int16_t nwk_decrypt_failures; ++ int16_t aps_decrypt_failures; ++ int16_t packet_buffer_allocate_failures; ++ int16_t relayed_ucast; ++ int16_t phy_to_mac_queue_limit_reached; ++ int16_t packet_validate_drop_count; ++ int16_t average_mac_retry_per_aps_message_sent; ++ int8_t last_messagelqi; + int8_t last_messagerssi; + } uic_mqtt_dotdot_diagnostics_state_t; + +@@ -34278,7 +34278,7 @@ void uic_mqtt_dotdot_clear_diagnostics_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34308,7 +34308,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34338,7 +34338,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34368,7 +34368,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34398,7 +34398,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34428,7 +34428,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34458,7 +34458,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34488,7 +34488,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34518,7 +34518,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34548,7 +34548,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34578,7 +34578,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34608,7 +34608,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34638,7 +34638,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34668,7 +34668,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34698,7 +34698,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34728,7 +34728,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34758,7 +34758,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34788,7 +34788,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34818,7 +34818,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34848,7 +34848,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34878,7 +34878,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34908,7 +34908,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34938,7 +34938,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34968,7 +34968,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34998,7 +34998,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35028,7 +35028,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35058,7 +35058,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_unretain + */ + sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35088,7 +35088,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35118,7 +35118,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35148,7 +35148,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35178,7 +35178,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_u + */ + sl_status_t uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35281,13 +35281,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report + + bool transmission_successful, + +- uint16_t transmission_time_ms, ++ int16_t transmission_time_ms, + + int8_t tx_powerd_bm, + +- uint8_t tx_channel, ++ int8_t tx_channel, + +- uint8_t routing_attempts, ++ int8_t routing_attempts, + + bool route_changed, + +@@ -35303,7 +35303,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report + + int8_t ackrssi, + +- uint8_t ack_channel, ++ int8_t ack_channel, + + const char* last_route_failed_link_functionalunid, + +@@ -35353,13 +35353,13 @@ typedef struct { + + bool transmission_successful; + +- uint16_t transmission_time_ms; ++ int16_t transmission_time_ms; + + int8_t tx_powerd_bm; + +- uint8_t tx_channel; ++ int8_t tx_channel; + +- uint8_t routing_attempts; ++ int8_t routing_attempts; + + bool route_changed; + +@@ -35375,7 +35375,7 @@ typedef struct { + + int8_t ackrssi; + +- uint8_t ack_channel; ++ int8_t ack_channel; + + const char* last_route_failed_link_functionalunid; + +@@ -35617,10 +35617,10 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_enable_nls_callback_t)( + + typedef struct { + size_t endpoint_id_list_count; +- const uint8_t* endpoint_id_list; ++ const int8_t* endpoint_id_list; + uint8_t network_status; + uint8_t security; +- uint32_t maximum_command_delay; ++ int32_t maximum_command_delay; + size_t network_list_count; + const char** network_list; + } uic_mqtt_dotdot_state_state_t; +@@ -35954,7 +35954,7 @@ void uic_mqtt_dotdot_clear_state_force_read_attributes_callbacks(); + sl_status_t uic_mqtt_dotdot_state_endpoint_id_list_publish( + const char *base_topic, + size_t value_count, +- const uint8_t* value, ++ const int8_t* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -36044,7 +36044,7 @@ sl_status_t uic_mqtt_dotdot_state_security_unretain( + */ + sl_status_t uic_mqtt_dotdot_state_maximum_command_delay_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -36147,7 +36147,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_binding_bind_callback_t)( + + const char* destination_unid, + +- uint8_t destination_ep ++ int8_t destination_ep + + ); + typedef sl_status_t (*uic_mqtt_dotdot_binding_unbind_callback_t)( +@@ -36158,7 +36158,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_binding_unbind_callback_t)( + + const char* destination_unid, + +- uint8_t destination_ep ++ int8_t destination_ep + + ); + typedef sl_status_t (*uic_mqtt_dotdot_binding_bind_to_protocol_controller_callback_t)( +@@ -36214,7 +36214,7 @@ typedef struct { + + const char* destination_unid; + +- uint8_t destination_ep; ++ int8_t destination_ep; + } uic_mqtt_dotdot_binding_command_bind_fields_t; + + /** +@@ -36225,7 +36225,7 @@ typedef struct { + + const char* destination_unid; + +- uint8_t destination_ep; ++ int8_t destination_ep; + } uic_mqtt_dotdot_binding_command_unbind_fields_t; + + /** +@@ -36594,7 +36594,7 @@ void uic_mqtt_dotdot_binding_publish_empty_supported_commands( + // Callback types used by the system_metrics cluster + + typedef struct { +- uint32_t reporting_interval_seconds; ++ int32_t reporting_interval_seconds; + size_t cpu_usage_percent_count; + const double* cpu_usage_percent; + size_t cpu_frequencym_hz_count; +@@ -36622,14 +36622,14 @@ typedef struct { + const WirelessNetworkInterfaceData* wireless_network_interfaces_data; + const char* hostname; + const char* fqdn; +- uint64_t uptime_minutes; ++ int64_t uptime_minutes; + double current_temperature_celcius; + double average_temperature_celcius; + double min_temperature_celcius; + double max_temperature_celcius; + bool power_plugged; + double battery_percentage; +- uint64_t system_interrupts; ++ int64_t system_interrupts; + } uic_mqtt_dotdot_system_metrics_state_t; + + typedef struct { +@@ -36741,7 +36741,7 @@ void uic_mqtt_dotdot_clear_system_metrics_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37329,7 +37329,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_fqdn_unretain( + */ + sl_status_t uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37539,7 +37539,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_battery_percentage_unretain( + */ + sl_status_t uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37622,20 +37622,20 @@ typedef struct { + bool application_connected; + size_t application_mqtt_topics_count; + const char** application_mqtt_topics; +- uint64_t uptime_minutes; +- uint64_t process_id; ++ int64_t uptime_minutes; ++ int64_t process_id; + const char* hostname; + const char* fqdn; + bool mqtt_logging_enabled; + uint8_t mqtt_logging_level; +- uint32_t mqtt_statistics_reporting_interval_seconds; +- uint64_t mqtt_messages_sent; +- uint64_t mqtt_messages_received; +- uint64_t mqtt_subscription_count; ++ int32_t mqtt_statistics_reporting_interval_seconds; ++ int64_t mqtt_messages_sent; ++ int64_t mqtt_messages_received; ++ int64_t mqtt_subscription_count; + double mqtt_average_delivery_time_seconds; + double mqtt_min_delivery_time_seconds; + double mqtt_max_delivery_time_seconds; +- uint32_t application_statistics_reporting_interval_seconds; ++ int32_t application_statistics_reporting_interval_seconds; + double application_cpu_usage_percent; + double application_cpu_average_usage_percent; + double application_cpu_min_usage_percent; +@@ -37923,7 +37923,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_application_mqtt_topics_unret + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37953,7 +37953,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_process_id_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38103,7 +38103,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_logging_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38133,7 +38133,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_int + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38163,7 +38163,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38193,7 +38193,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_unreta + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38313,7 +38313,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_max_delivery_time_second + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38556,505 +38556,2039 @@ typedef sl_status_t (*uic_mqtt_dotdot_name_and_location_force_read_attributes_ca + + + /** +- * @brief Setup a callback for WriteAttribute to be called when a +- * +/name_and_location/Commands/WriteAttributes is received. ++ * @brief Setup a callback for WriteAttribute to be called when a ++ * +/name_and_location/Commands/WriteAttributes is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_set_name_and_location_write_attributes_callback( ++ const uic_mqtt_dotdot_name_and_location_write_attributes_callback_t callback ++); ++/** ++ * @brief Unsets a callback for WriteAttribute to be called when a ++ * +/name_and_location/Commands/WriteAttributes is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_unset_name_and_location_write_attributes_callback( ++ const uic_mqtt_dotdot_name_and_location_write_attributes_callback_t callback ++); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/name_and_location/Commands/WriteAttributes is received. ++ */ ++void uic_mqtt_dotdot_clear_name_and_location_write_attributes_callbacks(); ++ ++/** ++ * @brief Setup a callback for ForceReadAttributes to be called when a ++ * +/name_and_location/Commands/ForceReadAttributes is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_set_name_and_location_force_read_attributes_callback( ++ const uic_mqtt_dotdot_name_and_location_force_read_attributes_callback_t callback ++); ++/** ++ * @brief Unsets a callback for ForceReadAttributes to be called when a ++ * +/name_and_location/Commands/ForceReadAttributes is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_unset_name_and_location_force_read_attributes_callback( ++ const uic_mqtt_dotdot_name_and_location_force_read_attributes_callback_t callback ++); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/name_and_location/Commands/ForceReadAttributes is received. ++ */ ++void uic_mqtt_dotdot_clear_name_and_location_force_read_attributes_callbacks(); ++ ++/** ++ * @brief Publish the attribute; NameAndLocation/Attributes/Name ++ * ++ * @param base_topic topic prefix to publish, /name ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_name_and_location_name_publish( ++ const char *base_topic, ++ const char* value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; NameAndLocation/Attributes/Name ++ * ++ * @param base_topic topic prefix to publish, /name ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_name_and_location_name_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; NameAndLocation/Attributes/Location ++ * ++ * @param base_topic topic prefix to publish, /location ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_name_and_location_location_publish( ++ const char *base_topic, ++ const char* value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; NameAndLocation/Attributes/Location ++ * ++ * @param base_topic topic prefix to publish, /location ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_name_and_location_location_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++ ++/** ++ * @brief Publish the NameAndLocation/ClusterRevision attribute ++ * ++ * @param base_topic topic prefix to publish, /NameAndLocation/Attributes/ClusterRevision ++ * will be appended. ++ * @param value Value to publish. ++ */ ++void uic_mqtt_dotdot_name_and_location_publish_cluster_revision(const char* base_topic, uint16_t value); ++ ++/** ++ * @brief Unretain a publication to NameAndLocation/ClusterRevision attribute ++ * ++ * @param base_topic topic prefix to publish, /NameAndLocation/Attributes/ClusterRevision ++ * will be appended. ++ */ ++void uic_mqtt_dotdot_name_and_location_unretain_cluster_revision(const char* base_topic); ++ ++/** ++ * @brief Publish the SupportedCommands for UNID/EndPoint for the NameAndLocation Cluster ++ * ++ * This function will iterate over all Commands in the NameAndLocation Cluster and ++ * call all registered callback functions with UNID/endpoint, and ++ * callback_type = UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK. ++ * All Cluster Command callback functions that return SL_STATUS_OK ++ * will be added to the list of supported commands and published. ++ * ++ * @param unid ++ * @param endpoint ++ */ ++void uic_mqtt_dotdot_name_and_location_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint); ++ ++/** ++ * @brief Publish an empty array of SupportedCommands for UNID/EndPoint for ++ * the NameAndLocation Cluster ++ * ++ * @param unid ++ * @param endpoint ) ++ */ ++void uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ,dotdot_endpoint_id_t endpoint); ++// Callback types used by the configuration_parameters cluster ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t parameter_id ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t parameter_id, ++ ++ int64_t value ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t first_parameter_id, ++ ++ int16_t last_parameter_id ++ ++); ++ ++typedef struct { ++ size_t configuration_parameters_count; ++ const ConfigurationParameter* configuration_parameters; ++} uic_mqtt_dotdot_configuration_parameters_state_t; ++ ++typedef struct { ++ bool configuration_parameters; ++} uic_mqtt_dotdot_configuration_parameters_updated_state_t; ++ ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t)( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_configuration_parameters_state_t, ++ uic_mqtt_dotdot_configuration_parameters_updated_state_t ++); ++ ++typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t)( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_configuration_parameters_updated_state_t ++); ++ ++ ++/** ++ * @brief Command fields for ConfigurationParameters/DiscoverParameter ++ */ ++typedef struct { ++ int16_t parameter_id; ++} uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_fields_t; ++ ++/** ++ * @brief Command fields for ConfigurationParameters/SetParameter ++ */ ++typedef struct { ++ int16_t parameter_id; ++ ++ int64_t value; ++} uic_mqtt_dotdot_configuration_parameters_command_set_parameter_fields_t; ++ ++/** ++ * @brief Command fields for ConfigurationParameters/DiscoverParameterRange ++ */ ++typedef struct { ++ int16_t first_parameter_id; ++ ++ int16_t last_parameter_id; ++} uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t; ++ ++ ++/** ++ * @brief Setup callback to be called when a ++ * ConfigurationParameters/Commands/discover_parameter is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * ConfigurationParameters/Commands/discover_parameter is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * ConfigurationParameters/Commands/discover_parameter is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_set(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_unset(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_set(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_unset(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * ConfigurationParameters/Commands/set_parameter is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * ConfigurationParameters/Commands/set_parameter is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * ConfigurationParameters/Commands/set_parameter is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * ConfigurationParameters/Commands/discover_parameter_range is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * ConfigurationParameters/Commands/discover_parameter_range is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * ConfigurationParameters/Commands/discover_parameter_range is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_clear(); ++ ++/** ++ * @brief Setup a callback for WriteAttribute to be called when a ++ * +/configuration_parameters/Commands/WriteAttributes is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_set_configuration_parameters_write_attributes_callback( ++ const uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t callback ++); ++/** ++ * @brief Unsets a callback for WriteAttribute to be called when a ++ * +/configuration_parameters/Commands/WriteAttributes is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_unset_configuration_parameters_write_attributes_callback( ++ const uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t callback ++); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/configuration_parameters/Commands/WriteAttributes is received. ++ */ ++void uic_mqtt_dotdot_clear_configuration_parameters_write_attributes_callbacks(); ++ ++/** ++ * @brief Setup a callback for ForceReadAttributes to be called when a ++ * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_set_configuration_parameters_force_read_attributes_callback( ++ const uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t callback ++); ++/** ++ * @brief Unsets a callback for ForceReadAttributes to be called when a ++ * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_unset_configuration_parameters_force_read_attributes_callback( ++ const uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t callback ++); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ */ ++void uic_mqtt_dotdot_clear_configuration_parameters_force_read_attributes_callbacks(); ++ ++/** ++ * @brief Publish the attribute; ConfigurationParameters/Attributes/ConfigurationParameters ++ * ++ * @param base_topic topic prefix to publish, /configuration_parameters ++ * will be appended ++ * @param value_count Size of the array contained at value ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_configuration_parameters_configuration_parameters_publish( ++ const char *base_topic, ++ size_t value_count, ++ const ConfigurationParameter* value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; ConfigurationParameters/Attributes/ConfigurationParameters ++ * ++ * @param base_topic topic prefix to publish, /configuration_parameters ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_configuration_parameters_configuration_parameters_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++ ++/** ++ * @brief Publish the ConfigurationParameters/ClusterRevision attribute ++ * ++ * @param base_topic topic prefix to publish, /ConfigurationParameters/Attributes/ClusterRevision ++ * will be appended. ++ * @param value Value to publish. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(const char* base_topic, uint16_t value); ++ ++/** ++ * @brief Unretain a publication to ConfigurationParameters/ClusterRevision attribute ++ * ++ * @param base_topic topic prefix to publish, /ConfigurationParameters/Attributes/ClusterRevision ++ * will be appended. ++ */ ++void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const char* base_topic); ++ ++/** ++ * @brief Publish the SupportedCommands for UNID/EndPoint for the ConfigurationParameters Cluster ++ * ++ * This function will iterate over all Commands in the ConfigurationParameters Cluster and ++ * call all registered callback functions with UNID/endpoint, and ++ * callback_type = UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK. ++ * All Cluster Command callback functions that return SL_STATUS_OK ++ * will be added to the list of supported commands and published. ++ * ++ * @param unid ++ * @param endpoint ++ */ ++void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint); ++ ++/** ++ * @brief Publish an empty array of SupportedCommands for UNID/EndPoint for ++ * the ConfigurationParameters Cluster ++ * ++ * @param unid ++ * @param endpoint ) ++ */ ++void uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ,dotdot_endpoint_id_t endpoint); ++// Callback types used by the user_credential cluster ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_add_user_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ UserTypeEnum user_type, ++ ++ bool user_active_state, ++ ++ CredRule credential_rule, ++ ++ const char* user_name, ++ ++ int16_t expiring_timeout_minutes, ++ ++ UserNameEncodingType user_name_encoding ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_modify_user_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ UserTypeEnum user_type, ++ ++ bool user_active_state, ++ ++ CredRule credential_rule, ++ ++ const char* user_name, ++ ++ int16_t expiring_timeout_minutes, ++ ++ UserNameEncodingType user_name_encoding ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_user_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_add_credential_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ const char* credential_data ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_modify_credential_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ const char* credential_data ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_credential_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_users_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ CredType credential_type ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ int8_t credential_learn_timeout ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ int8_t credential_learn_timeout ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_association_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ CredType credential_type, ++ ++ int16_t source_user_uniqueid, ++ ++ int16_t source_credential_slot, ++ ++ int16_t destination_user_uniqueid, ++ ++ int16_t destination_credential_slot ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ int16_t user_uniqueid ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ CredType credential_type ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ const char* pin_code ++ ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type ++); ++ ++typedef struct { ++ int16_t supported_user_unique_identifiers; ++ uint8_t supported_credential_rules; ++ uint16_t supported_credential_types; ++ uint16_t supported_user_types; ++ bool support_credential_checksum; ++ bool support_admin_pin_code; ++ bool support_admin_pin_code_deactivation; ++ const char* admin_pin_code; ++} uic_mqtt_dotdot_user_credential_state_t; ++ ++typedef struct { ++ bool supported_user_unique_identifiers; ++ bool supported_credential_rules; ++ bool supported_credential_types; ++ bool supported_user_types; ++ bool support_credential_checksum; ++ bool support_admin_pin_code; ++ bool support_admin_pin_code_deactivation; ++ bool admin_pin_code; ++} uic_mqtt_dotdot_user_credential_updated_state_t; ++ ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_write_attributes_callback_t)( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_user_credential_state_t, ++ uic_mqtt_dotdot_user_credential_updated_state_t ++); ++ ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t)( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_user_credential_updated_state_t ++); ++ ++ ++/** ++ * @brief Command fields for UserCredential/AddUser ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ UserTypeEnum user_type; ++ ++ bool user_active_state; ++ ++ CredRule credential_rule; ++ ++ const char* user_name; ++ ++ int16_t expiring_timeout_minutes; ++ ++ UserNameEncodingType user_name_encoding; ++} uic_mqtt_dotdot_user_credential_command_add_user_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/ModifyUser ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ UserTypeEnum user_type; ++ ++ bool user_active_state; ++ ++ CredRule credential_rule; ++ ++ const char* user_name; ++ ++ int16_t expiring_timeout_minutes; ++ ++ UserNameEncodingType user_name_encoding; ++} uic_mqtt_dotdot_user_credential_command_modify_user_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/DeleteUser ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++} uic_mqtt_dotdot_user_credential_command_delete_user_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/AddCredential ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++ ++ int16_t credential_slot; ++ ++ const char* credential_data; ++} uic_mqtt_dotdot_user_credential_command_add_credential_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/ModifyCredential ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++ ++ int16_t credential_slot; ++ ++ const char* credential_data; ++} uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/DeleteCredential ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++ ++ int16_t credential_slot; ++} uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/DeleteAllCredentialsByType ++ */ ++typedef struct { ++ CredType credential_type; ++} uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/DeleteAllCredentialsForUser ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++} uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/DeleteAllCredentialsForUserByType ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++} uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/CredentialLearnStartAdd ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++ ++ int16_t credential_slot; ++ ++ int8_t credential_learn_timeout; ++} uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/CredentialLearnStartModify ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++ ++ CredType credential_type; ++ ++ int16_t credential_slot; ++ ++ int8_t credential_learn_timeout; ++} uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/CredentialAssociation ++ */ ++typedef struct { ++ CredType credential_type; ++ ++ int16_t source_user_uniqueid; ++ ++ int16_t source_credential_slot; ++ ++ int16_t destination_user_uniqueid; ++ ++ int16_t destination_credential_slot; ++} uic_mqtt_dotdot_user_credential_command_credential_association_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/GetUserChecksum ++ */ ++typedef struct { ++ int16_t user_uniqueid; ++} uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/GetCredentialChecksum ++ */ ++typedef struct { ++ CredType credential_type; ++} uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t; ++ ++/** ++ * @brief Command fields for UserCredential/SetAdminPINCode ++ */ ++typedef struct { ++ const char* pin_code; ++} uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t; ++ ++ ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/add_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_add_user_callback_set(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/add_user is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_add_user_callback_unset(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/add_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_add_user_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/add_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_set(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/add_user is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_unset(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/add_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/modify_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_modify_user_callback_set(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/modify_user is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_modify_user_callback_unset(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/modify_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_modify_user_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/modify_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_set(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/modify_user is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_unset(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/modify_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_user is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_user_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_user is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/add_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_add_credential_callback_set(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/add_credential is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_add_credential_callback_unset(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/add_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_add_credential_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/add_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_set(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/add_credential is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_unset(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/add_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/modify_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_set(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/modify_credential is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_unset(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/modify_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/modify_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_set(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/modify_credential is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_unset(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/modify_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_set(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_credential is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_unset(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_credential is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_set(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_credential is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_unset(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_credential is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_all_users is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_all_users is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_all_users is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_users is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_users is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_all_users is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_all_credentials is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_all_credentials is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_all_credentials is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_all_credentials is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_by_type is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_by_type is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_all_credentials_by_type is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_by_type is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_by_type is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_by_type is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_for_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_for_user is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_all_credentials_for_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_for_user_by_type is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/delete_all_credentials_for_user_by_type is received. ++ * ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/delete_all_credentials_for_user_by_type is received. ++ */ ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_clear(); ++ ++/** ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user_by_type is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user_by_type is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/delete_all_credentials_for_user_by_type is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/credential_learn_start_add is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_set_name_and_location_write_attributes_callback( +- const uic_mqtt_dotdot_name_and_location_write_attributes_callback_t callback +-); ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback); + /** +- * @brief Unsets a callback for WriteAttribute to be called when a +- * +/name_and_location/Commands/WriteAttributes is received. ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/credential_learn_start_add is received. ++ * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_unset_name_and_location_write_attributes_callback( +- const uic_mqtt_dotdot_name_and_location_write_attributes_callback_t callback +-); ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/name_and_location/Commands/WriteAttributes is received. ++ * UserCredential/Commands/credential_learn_start_add is received. + */ +-void uic_mqtt_dotdot_clear_name_and_location_write_attributes_callbacks(); ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_clear(); + + /** +- * @brief Setup a callback for ForceReadAttributes to be called when a +- * +/name_and_location/Commands/ForceReadAttributes is received. ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_start_add is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_set_name_and_location_force_read_attributes_callback( +- const uic_mqtt_dotdot_name_and_location_force_read_attributes_callback_t callback +-); ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback); + /** +- * @brief Unsets a callback for ForceReadAttributes to be called when a +- * +/name_and_location/Commands/ForceReadAttributes is received. +- * ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_start_add is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_unset_name_and_location_force_read_attributes_callback( +- const uic_mqtt_dotdot_name_and_location_force_read_attributes_callback_t callback +-); ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/name_and_location/Commands/ForceReadAttributes is received. ++ * +/UserCredential/GeneratedCommands/credential_learn_start_add is received. + */ +-void uic_mqtt_dotdot_clear_name_and_location_force_read_attributes_callbacks(); +- ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_clear(); + /** +- * @brief Publish the attribute; NameAndLocation/Attributes/Name ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/credential_learn_start_modify is received. + * +- * @param base_topic topic prefix to publish, /name +- * will be appended +- * @param value Value to publish +- * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/credential_learn_start_modify is received. + * +- * @returns SL_STATUS_OK on success ++ * @param callback Function to be no longer called on command reception + */ +-sl_status_t uic_mqtt_dotdot_name_and_location_name_publish( +- const char *base_topic, +- const char* value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-); ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/credential_learn_start_modify is received. ++ */ ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_clear(); + + /** +- * @brief Unretains a published attribute; NameAndLocation/Attributes/Name +- * +- * @param base_topic topic prefix to publish, /name +- * will be appended +- * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_start_modify is received. + * +- * @returns SL_STATUS_OK on success ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception + */ +-sl_status_t uic_mqtt_dotdot_name_and_location_name_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-); +- ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback); + /** +- * @brief Publish the attribute; NameAndLocation/Attributes/Location ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_start_modify is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/credential_learn_start_modify is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/credential_learn_stop is received. + * +- * @param base_topic topic prefix to publish, /location +- * will be appended +- * @param value Value to publish +- * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/credential_learn_stop is received. + * +- * @returns SL_STATUS_OK on success ++ * @param callback Function to be no longer called on command reception + */ +-sl_status_t uic_mqtt_dotdot_name_and_location_location_publish( +- const char *base_topic, +- const char* value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-); ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/credential_learn_stop is received. ++ */ ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_clear(); + + /** +- * @brief Unretains a published attribute; NameAndLocation/Attributes/Location +- * +- * @param base_topic topic prefix to publish, /location +- * will be appended +- * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_stop is received. + * +- * @returns SL_STATUS_OK on success ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception + */ +-sl_status_t uic_mqtt_dotdot_name_and_location_location_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-); +- +- ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback); + /** +- * @brief Publish the NameAndLocation/ClusterRevision attribute ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_learn_stop is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/credential_learn_stop is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/credential_association is received. + * +- * @param base_topic topic prefix to publish, /NameAndLocation/Attributes/ClusterRevision +- * will be appended. +- * @param value Value to publish. ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_name_and_location_publish_cluster_revision(const char* base_topic, uint16_t value); +- ++void uic_mqtt_dotdot_user_credential_credential_association_callback_set(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback); + /** +- * @brief Unretain a publication to NameAndLocation/ClusterRevision attribute ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/credential_association is received. + * +- * @param base_topic topic prefix to publish, /NameAndLocation/Attributes/ClusterRevision +- * will be appended. ++ * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_name_and_location_unretain_cluster_revision(const char* base_topic); ++void uic_mqtt_dotdot_user_credential_credential_association_callback_unset(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/credential_association is received. ++ */ ++void uic_mqtt_dotdot_user_credential_credential_association_callback_clear(); + + /** +- * @brief Publish the SupportedCommands for UNID/EndPoint for the NameAndLocation Cluster ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_association is received. + * +- * This function will iterate over all Commands in the NameAndLocation Cluster and +- * call all registered callback functions with UNID/endpoint, and +- * callback_type = UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK. +- * All Cluster Command callback functions that return SL_STATUS_OK +- * will be added to the list of supported commands and published. ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_set(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback); ++/** ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/credential_association is received. ++ * @param callback Function to be no longer called on command reception ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_unset(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/credential_association is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_clear(); ++/** ++ * @brief Setup callback to be called when a ++ * UserCredential/Commands/get_user_checksum is received. + * +- * @param unid +- * @param endpoint ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_name_and_location_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint); +- ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback); + /** +- * @brief Publish an empty array of SupportedCommands for UNID/EndPoint for +- * the NameAndLocation Cluster ++ * @brief Unsets callback to be called when a ++ * UserCredential/Commands/get_user_checksum is received. + * +- * @param unid +- * @param endpoint ) ++ * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands( +- const dotdot_unid_t unid +- ,dotdot_endpoint_id_t endpoint); +-// Callback types used by the configuration_parameters cluster +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t)( +- dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t parameter_id +- +-); +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t)( +- dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type +-); +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t)( +- dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t parameter_id, +- +- int64_t value +- +-); +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t)( +- dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type, +- uint16_t first_parameter_id, +- +- uint16_t last_parameter_id +- +-); +- +-typedef struct { +- size_t configuration_parameters_count; +- const ConfigurationParameter* configuration_parameters; +-} uic_mqtt_dotdot_configuration_parameters_state_t; +- +-typedef struct { +- bool configuration_parameters; +-} uic_mqtt_dotdot_configuration_parameters_updated_state_t; +- +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t)( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type, +- uic_mqtt_dotdot_configuration_parameters_state_t, +- uic_mqtt_dotdot_configuration_parameters_updated_state_t +-); +- +-typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t)( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- uic_mqtt_dotdot_callback_call_type_t call_type, +- uic_mqtt_dotdot_configuration_parameters_updated_state_t +-); +- +- ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback); + /** +- * @brief Command fields for ConfigurationParameters/DiscoverParameter ++ * @brief Clears all callbacks registered for when ++ * UserCredential/Commands/get_user_checksum is received. + */ +-typedef struct { +- uint16_t parameter_id; +-} uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_fields_t; ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_clear(); + + /** +- * @brief Command fields for ConfigurationParameters/SetParameter ++ * @brief Setup callback to be called when a ++ * +/UserCredential/GeneratedCommands/get_user_checksum is received. ++ * ++ * Setting this callback will not overwrite the previous set callback ++ * @param callback Function to be called on command reception + */ +-typedef struct { +- uint16_t parameter_id; +- +- int64_t value; +-} uic_mqtt_dotdot_configuration_parameters_command_set_parameter_fields_t; +- ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback); + /** +- * @brief Command fields for ConfigurationParameters/DiscoverParameterRange ++ * @brief Unsets callback to be called when a ++ * +/UserCredential/GeneratedCommands/get_user_checksum is received. ++ * @param callback Function to be no longer called on command reception + */ +-typedef struct { +- uint16_t first_parameter_id; +- +- uint16_t last_parameter_id; +-} uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t; +- +- ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback); ++/** ++ * @brief Clears all callbacks registered for when ++ * +/UserCredential/GeneratedCommands/get_user_checksum is received. ++ */ ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_clear(); + /** + * @brief Setup callback to be called when a +- * ConfigurationParameters/Commands/discover_parameter is received. ++ * UserCredential/Commands/get_credential_checksum is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * ConfigurationParameters/Commands/discover_parameter is received. ++ * UserCredential/Commands/get_credential_checksum is received. + * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * ConfigurationParameters/Commands/discover_parameter is received. ++ * UserCredential/Commands/get_credential_checksum is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_clear(); ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_clear(); + + /** + * @brief Setup callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ * +/UserCredential/GeneratedCommands/get_credential_checksum is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ * +/UserCredential/GeneratedCommands/get_credential_checksum is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter is received. ++ * +/UserCredential/GeneratedCommands/get_credential_checksum is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_callback_clear(); ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_clear(); + /** + * @brief Setup callback to be called when a +- * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ * UserCredential/Commands/get_all_users_checksum is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_set(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ * UserCredential/Commands/get_all_users_checksum is received. + * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_unset(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * ConfigurationParameters/Commands/default_reset_all_parameters is received. ++ * UserCredential/Commands/get_all_users_checksum is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_clear(); ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_clear(); + + /** + * @brief Setup callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ * +/UserCredential/GeneratedCommands/get_all_users_checksum is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_set(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ * +/UserCredential/GeneratedCommands/get_all_users_checksum is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_unset(const uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/ConfigurationParameters/GeneratedCommands/default_reset_all_parameters is received. ++ * +/UserCredential/GeneratedCommands/get_all_users_checksum is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_default_reset_all_parameters_callback_clear(); ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_clear(); + /** + * @brief Setup callback to be called when a +- * ConfigurationParameters/Commands/set_parameter is received. ++ * UserCredential/Commands/set_admin_pin_code is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * ConfigurationParameters/Commands/set_parameter is received. ++ * UserCredential/Commands/set_admin_pin_code is received. + * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * ConfigurationParameters/Commands/set_parameter is received. ++ * UserCredential/Commands/set_admin_pin_code is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_clear(); ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_clear(); + + /** + * @brief Setup callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ * +/UserCredential/GeneratedCommands/set_admin_pin_code is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_set(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ * +/UserCredential/GeneratedCommands/set_admin_pin_code is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_unset(const uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/ConfigurationParameters/GeneratedCommands/set_parameter is received. ++ * +/UserCredential/GeneratedCommands/set_admin_pin_code is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_set_parameter_callback_clear(); ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_clear(); + /** + * @brief Setup callback to be called when a +- * ConfigurationParameters/Commands/discover_parameter_range is received. ++ * UserCredential/Commands/deactivate_admin_pin_code is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * ConfigurationParameters/Commands/discover_parameter_range is received. ++ * UserCredential/Commands/deactivate_admin_pin_code is received. + * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * ConfigurationParameters/Commands/discover_parameter_range is received. ++ * UserCredential/Commands/deactivate_admin_pin_code is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_clear(); ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_clear(); + + /** + * @brief Setup callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ * +/UserCredential/GeneratedCommands/deactivate_admin_pin_code is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_set(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback); + /** + * @brief Unsets callback to be called when a +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ * +/UserCredential/GeneratedCommands/deactivate_admin_pin_code is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_unset(const uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t callback); ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback); + /** + * @brief Clears all callbacks registered for when +- * +/ConfigurationParameters/GeneratedCommands/discover_parameter_range is received. ++ * +/UserCredential/GeneratedCommands/deactivate_admin_pin_code is received. + */ +-void uic_mqtt_dotdot_configuration_parameters_generated_discover_parameter_range_callback_clear(); ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_clear(); + + /** + * @brief Setup a callback for WriteAttribute to be called when a +- * +/configuration_parameters/Commands/WriteAttributes is received. ++ * +/user_credential/Commands/WriteAttributes is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_set_configuration_parameters_write_attributes_callback( +- const uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t callback ++void uic_mqtt_dotdot_set_user_credential_write_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_write_attributes_callback_t callback + ); + /** + * @brief Unsets a callback for WriteAttribute to be called when a +- * +/configuration_parameters/Commands/WriteAttributes is received. ++ * +/user_credential/Commands/WriteAttributes is received. + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_unset_configuration_parameters_write_attributes_callback( +- const uic_mqtt_dotdot_configuration_parameters_write_attributes_callback_t callback ++void uic_mqtt_dotdot_unset_user_credential_write_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_write_attributes_callback_t callback + ); + /** + * @brief Clears all callbacks registered for when +- * +/configuration_parameters/Commands/WriteAttributes is received. ++ * +/user_credential/Commands/WriteAttributes is received. + */ +-void uic_mqtt_dotdot_clear_configuration_parameters_write_attributes_callbacks(); ++void uic_mqtt_dotdot_clear_user_credential_write_attributes_callbacks(); + + /** + * @brief Setup a callback for ForceReadAttributes to be called when a +- * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ * +/user_credential/Commands/ForceReadAttributes is received. + * + * Setting this callback will not overwrite the previous set callback + * @param callback Function to be called on command reception + */ +-void uic_mqtt_dotdot_set_configuration_parameters_force_read_attributes_callback( +- const uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t callback ++void uic_mqtt_dotdot_set_user_credential_force_read_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t callback + ); + /** + * @brief Unsets a callback for ForceReadAttributes to be called when a +- * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ * +/user_credential/Commands/ForceReadAttributes is received. + * + * @param callback Function to be no longer called on command reception + */ +-void uic_mqtt_dotdot_unset_configuration_parameters_force_read_attributes_callback( +- const uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback_t callback ++void uic_mqtt_dotdot_unset_user_credential_force_read_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t callback + ); + /** + * @brief Clears all callbacks registered for when +- * +/configuration_parameters/Commands/ForceReadAttributes is received. ++ * +/user_credential/Commands/ForceReadAttributes is received. + */ +-void uic_mqtt_dotdot_clear_configuration_parameters_force_read_attributes_callbacks(); ++void uic_mqtt_dotdot_clear_user_credential_force_read_attributes_callbacks(); + + /** +- * @brief Publish the attribute; ConfigurationParameters/Attributes/ConfigurationParameters ++ * @brief Publish the attribute; UserCredential/Attributes/SupportedUserUniqueIdentifiers + * +- * @param base_topic topic prefix to publish, /configuration_parameters ++ * @param base_topic topic prefix to publish, /supported_user_unique_identifiers + * will be appended +- * @param value_count Size of the array contained at value + * @param value Value to publish + * @param publish_type Whether to publish as Desired, Reported, or Both. + * + * @returns SL_STATUS_OK on success + */ +-sl_status_t uic_mqtt_dotdot_configuration_parameters_configuration_parameters_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( + const char *base_topic, +- size_t value_count, +- const ConfigurationParameter* value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + + /** +- * @brief Unretains a published attribute; ConfigurationParameters/Attributes/ConfigurationParameters ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportedUserUniqueIdentifiers + * +- * @param base_topic topic prefix to publish, /configuration_parameters ++ * @param base_topic topic prefix to publish, /supported_user_unique_identifiers + * will be appended + * @param publish_type Whether to publish as Desired, Reported, or Both. + * + * @returns SL_STATUS_OK on success + */ +-sl_status_t uic_mqtt_dotdot_configuration_parameters_configuration_parameters_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/SupportedCredentialRules ++ * ++ * @param base_topic topic prefix to publish, /supported_credential_rules ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_rules_publish( + const char *base_topic, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportedCredentialRules ++ * ++ * @param base_topic topic prefix to publish, /supported_credential_rules ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_rules_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); + + /** +- * @brief Publish the ConfigurationParameters/ClusterRevision attribute ++ * @brief Publish the attribute; UserCredential/Attributes/SupportedCredentialTypes + * +- * @param base_topic topic prefix to publish, /ConfigurationParameters/Attributes/ClusterRevision ++ * @param base_topic topic prefix to publish, /supported_credential_types ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_types_publish( ++ const char *base_topic, ++ uint16_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportedCredentialTypes ++ * ++ * @param base_topic topic prefix to publish, /supported_credential_types ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_types_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/SupportedUserTypes ++ * ++ * @param base_topic topic prefix to publish, /supported_user_types ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_types_publish( ++ const char *base_topic, ++ uint16_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportedUserTypes ++ * ++ * @param base_topic topic prefix to publish, /supported_user_types ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_types_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/SupportCredentialChecksum ++ * ++ * @param base_topic topic prefix to publish, /support_credential_checksum ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_credential_checksum_publish( ++ const char *base_topic, ++ bool value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportCredentialChecksum ++ * ++ * @param base_topic topic prefix to publish, /support_credential_checksum ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_credential_checksum_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/SupportAdminPinCode ++ * ++ * @param base_topic topic prefix to publish, /support_admin_pin_code ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_publish( ++ const char *base_topic, ++ bool value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportAdminPinCode ++ * ++ * @param base_topic topic prefix to publish, /support_admin_pin_code ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/SupportAdminPinCodeDeactivation ++ * ++ * @param base_topic topic prefix to publish, /support_admin_pin_code_deactivation ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_publish( ++ const char *base_topic, ++ bool value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/SupportAdminPinCodeDeactivation ++ * ++ * @param base_topic topic prefix to publish, /support_admin_pin_code_deactivation ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Publish the attribute; UserCredential/Attributes/AdminPinCode ++ * ++ * @param base_topic topic prefix to publish, /admin_pin_code ++ * will be appended ++ * @param value Value to publish ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_admin_pin_code_publish( ++ const char *base_topic, ++ const char* value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++/** ++ * @brief Unretains a published attribute; UserCredential/Attributes/AdminPinCode ++ * ++ * @param base_topic topic prefix to publish, /admin_pin_code ++ * will be appended ++ * @param publish_type Whether to publish as Desired, Reported, or Both. ++ * ++ * @returns SL_STATUS_OK on success ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_admin_pin_code_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++); ++ ++ ++/** ++ * @brief Publish the UserCredential/ClusterRevision attribute ++ * ++ * @param base_topic topic prefix to publish, /UserCredential/Attributes/ClusterRevision + * will be appended. + * @param value Value to publish. + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(const char* base_topic, uint16_t value); ++void uic_mqtt_dotdot_user_credential_publish_cluster_revision(const char* base_topic, uint16_t value); + + /** +- * @brief Unretain a publication to ConfigurationParameters/ClusterRevision attribute ++ * @brief Unretain a publication to UserCredential/ClusterRevision attribute + * +- * @param base_topic topic prefix to publish, /ConfigurationParameters/Attributes/ClusterRevision ++ * @param base_topic topic prefix to publish, /UserCredential/Attributes/ClusterRevision + * will be appended. + */ +-void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const char* base_topic); ++void uic_mqtt_dotdot_user_credential_unretain_cluster_revision(const char* base_topic); + + /** +- * @brief Publish the SupportedCommands for UNID/EndPoint for the ConfigurationParameters Cluster ++ * @brief Publish the SupportedCommands for UNID/EndPoint for the UserCredential Cluster + * +- * This function will iterate over all Commands in the ConfigurationParameters Cluster and ++ * This function will iterate over all Commands in the UserCredential Cluster and + * call all registered callback functions with UNID/endpoint, and + * callback_type = UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK. + * All Cluster Command callback functions that return SL_STATUS_OK +@@ -39063,18 +40597,18 @@ void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const ch + * @param unid + * @param endpoint + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( ++void uic_mqtt_dotdot_user_credential_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint); + + /** + * @brief Publish an empty array of SupportedCommands for UNID/EndPoint for +- * the ConfigurationParameters Cluster ++ * the UserCredential Cluster + * + * @param unid + * @param endpoint ) + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands( ++void uic_mqtt_dotdot_user_credential_publish_empty_supported_commands( + const dotdot_unid_t unid + ,dotdot_endpoint_id_t endpoint); + // Callback types used by the protocol_controller_network_management cluster +@@ -39970,9 +41504,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callba + uic_mqtt_dotdot_callback_call_type_t call_type, + SetpointType type, + +- uint8_t precision, ++ int8_t precision, + +- uint8_t scale, ++ int8_t scale, + + int32_t value + +@@ -39987,17 +41521,17 @@ typedef struct { + int32_t humidifier_setpoint_max; + int32_t humidifier_setpoint; + uint8_t humidifier_setpoint_scale; +- uint8_t humidifier_setpoint_precision; ++ int8_t humidifier_setpoint_precision; + int32_t dehumidifier_setpoint_min; + int32_t dehumidifier_setpoint_max; + int32_t dehumidifier_setpoint; + uint8_t dehumidifier_setpoint_scale; +- uint8_t dehumidifier_setpoint_precision; ++ int8_t dehumidifier_setpoint_precision; + int32_t auto_setpoint_min; + int32_t auto_setpoint_max; + int32_t auto_setpoint; + uint8_t auto_setpoint_scale; +- uint8_t auto_setpoint_precision; ++ int8_t auto_setpoint_precision; + } uic_mqtt_dotdot_unify_humidity_control_state_t; + + typedef struct { +@@ -40051,9 +41585,9 @@ typedef struct { + typedef struct { + SetpointType type; + +- uint8_t precision; ++ int8_t precision; + +- uint8_t scale; ++ int8_t scale; + + int32_t value; + } uic_mqtt_dotdot_unify_humidity_control_command_setpoint_set_fields_t; +@@ -40441,7 +41975,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_unr + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -40591,7 +42125,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_u + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -40741,7 +42275,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h +index 68b51b7e03..9dabf5aedf 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h +@@ -48,28 +48,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_zcl_version_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t zcl_version ++ int8_t zcl_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_application_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t application_version ++ int8_t application_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_stack_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t stack_version ++ int8_t stack_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_hw_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t hw_version ++ int8_t hw_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_manufacturer_name_callback_t)( + dotdot_unid_t unid, +@@ -118,7 +118,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_product_code_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- const char* product_code ++ uint8_t product_code + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_producturl_callback_t)( + dotdot_unid_t unid, +@@ -196,14 +196,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mains_voltage ++ int16_t mains_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t mains_frequency ++ int8_t mains_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -217,35 +217,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mains_voltage_min_threshold ++ int16_t mains_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltage_max_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mains_voltage_max_threshold ++ int16_t mains_voltage_max_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltage_dwell_trip_point_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mains_voltage_dwell_trip_point ++ int16_t mains_voltage_dwell_trip_point + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_voltage ++ int8_t battery_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_percentage_remaining ++ int8_t battery_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -266,21 +266,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_batterya_hr_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t batterya_hr_rating ++ int16_t batterya_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_quantity ++ int8_t battery_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_rated_voltage ++ int8_t battery_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -294,56 +294,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_volt + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_voltage_min_threshold ++ int8_t battery_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_voltage_threshold1 ++ int8_t battery_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_voltage_threshold2 ++ int8_t battery_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_voltage_threshold3 ++ int8_t battery_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_percentage_min_threshold ++ int8_t battery_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_percentage_threshold1 ++ int8_t battery_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_percentage_threshold2 ++ int8_t battery_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery_percentage_threshold3 ++ int8_t battery_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -357,14 +357,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_voltage ++ int8_t battery2_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_percentage_remaining ++ int8_t battery2_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -385,21 +385,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2a_hr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t battery2a_hr_rating ++ int16_t battery2a_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_quantity ++ int8_t battery2_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_rated_voltage ++ int8_t battery2_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -413,56 +413,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_voltage_min_threshold ++ int8_t battery2_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_voltage_threshold1 ++ int8_t battery2_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_voltage_threshold2 ++ int8_t battery2_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_voltage_threshold3 ++ int8_t battery2_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_percentage_min_threshold ++ int8_t battery2_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_percentage_threshold1 ++ int8_t battery2_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_percentage_threshold2 ++ int8_t battery2_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery2_percentage_threshold3 ++ int8_t battery2_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -476,14 +476,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_voltage ++ int8_t battery3_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_percentage_remaining ++ int8_t battery3_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -504,21 +504,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3a_hr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t battery3a_hr_rating ++ int16_t battery3a_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_quantity ++ int8_t battery3_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_rated_voltage ++ int8_t battery3_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -532,56 +532,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_voltage_min_threshold ++ int8_t battery3_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_voltage_threshold1 ++ int8_t battery3_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_voltage_threshold2 ++ int8_t battery3_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_voltage_threshold3 ++ int8_t battery3_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_percentage_min_threshold ++ int8_t battery3_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_percentage_threshold1 ++ int8_t battery3_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_percentage_threshold2 ++ int8_t battery3_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t battery3_percentage_threshold3 ++ int8_t battery3_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -617,7 +617,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t over_temp_total_dwell ++ int16_t over_temp_total_dwell + ); + typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute_device_temp_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -645,14 +645,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t low_temp_dwell_trip_point ++ int32_t low_temp_dwell_trip_point + ); + typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute_high_temp_dwell_trip_point_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t high_temp_dwell_trip_point ++ int32_t high_temp_dwell_trip_point + ); + // Callback types used by the identify cluster + typedef sl_status_t (*uic_mqtt_dotdot_identify_attribute_identify_time_callback_t)( +@@ -660,7 +660,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_attribute_identify_time_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t identify_time ++ int16_t identify_time + ); + // Callback types used by the groups cluster + typedef sl_status_t (*uic_mqtt_dotdot_groups_attribute_name_support_callback_t)( +@@ -676,21 +676,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_scene_count_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t scene_count ++ int8_t scene_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_current_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_scene ++ int8_t current_scene + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_current_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t current_group ++ uint8_t * current_group + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_scene_valid_callback_t)( + dotdot_unid_t unid, +@@ -741,14 +741,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_on_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t on_time ++ int16_t on_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_off_wait_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t off_wait_time ++ int16_t off_wait_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_start_up_on_off_callback_t)( + dotdot_unid_t unid, +@@ -763,49 +763,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_current_level_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_level ++ int8_t current_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_remaining_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t remaining_time ++ int16_t remaining_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_min_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t min_level ++ int8_t min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t max_level ++ int8_t max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_current_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t current_frequency ++ int16_t current_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_min_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_frequency ++ int16_t min_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_max_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_frequency ++ int16_t max_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_options_callback_t)( + dotdot_unid_t unid, +@@ -819,42 +819,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_off_transition_time_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t on_off_transition_time ++ int16_t on_off_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t on_level ++ int8_t on_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_transition_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t on_transition_time ++ int16_t on_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_off_transition_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t off_transition_time ++ int16_t off_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_default_move_rate_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t default_move_rate ++ int16_t default_move_rate + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_start_up_current_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t start_up_current_level ++ int8_t start_up_current_level + ); + // Callback types used by the alarms cluster + typedef sl_status_t (*uic_mqtt_dotdot_alarms_attribute_alarm_count_callback_t)( +@@ -862,7 +862,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_attribute_alarm_count_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t alarm_count ++ int16_t alarm_count + ); + // Callback types used by the time cluster + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_callback_t)( +@@ -870,7 +870,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t time ++ uint8_t time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_status_callback_t)( + dotdot_unid_t unid, +@@ -891,14 +891,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_start_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t dst_start ++ int32_t dst_start + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_end_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t dst_end ++ int32_t dst_end + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_shift_callback_t)( + dotdot_unid_t unid, +@@ -912,28 +912,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_standard_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t standard_time ++ int32_t standard_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_local_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t local_time ++ int32_t local_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_last_set_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t last_set_time ++ uint8_t last_set_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_valid_until_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t valid_until_time ++ uint8_t valid_until_time + ); + // Callback types used by the poll_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_callback_t)( +@@ -941,49 +941,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_c + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t check_in_interval ++ int32_t check_in_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_long_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t long_poll_interval ++ int32_t long_poll_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_short_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t short_poll_interval ++ int16_t short_poll_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_fast_poll_timeout_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t fast_poll_timeout ++ int16_t fast_poll_timeout + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t check_in_interval_min ++ int32_t check_in_interval_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_long_poll_interval_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t long_poll_interval_min ++ int32_t long_poll_interval_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_fast_poll_timeout_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t fast_poll_timeout_max ++ int16_t fast_poll_timeout_max + ); + // Callback types used by the shade_configuration cluster + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_physical_closed_limit_callback_t)( +@@ -991,14 +991,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_physical_clo + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t physical_closed_limit ++ int16_t physical_closed_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_motor_step_size_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t motor_step_size ++ int8_t motor_step_size + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_status_callback_t)( + dotdot_unid_t unid, +@@ -1012,7 +1012,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_closed_limit + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t closed_limit ++ int16_t closed_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_mode_callback_t)( + dotdot_unid_t unid, +@@ -1055,98 +1055,98 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_door_open_events_callb + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t door_open_events ++ int32_t door_open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_door_closed_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t door_closed_events ++ int32_t door_closed_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_open_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t open_period ++ int16_t open_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_log_records_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_log_records_supported ++ int16_t number_of_log_records_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_total_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_total_users_supported ++ int16_t number_of_total_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_pin_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_pin_users_supported ++ int16_t number_of_pin_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_rfid_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_rfid_users_supported ++ int16_t number_of_rfid_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_week_day_schedules_supported_per_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_week_day_schedules_supported_per_user ++ int8_t number_of_week_day_schedules_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_year_day_schedules_supported_per_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_year_day_schedules_supported_per_user ++ int8_t number_of_year_day_schedules_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_holiday_schedules_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_holiday_schedules_supported ++ int8_t number_of_holiday_schedules_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_max_pin_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t max_pin_code_length ++ int8_t max_pin_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_min_pin_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t min_pin_code_length ++ int8_t min_pin_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_max_rfid_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t max_rfid_code_length ++ int8_t max_rfid_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_min_rfid_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t min_rfid_code_length ++ int8_t min_rfid_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_credential_rules_support_callback_t)( + dotdot_unid_t unid, +@@ -1160,7 +1160,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_credentials_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_credentials_supported_per_user ++ int8_t number_of_credentials_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_enable_logging_callback_t)( + dotdot_unid_t unid, +@@ -1181,21 +1181,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_led_settings_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t led_settings ++ int8_t led_settings + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_auto_relock_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t auto_relock_time ++ int32_t auto_relock_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_sound_volume_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t sound_volume ++ int8_t sound_volume + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_operating_mode_callback_t)( + dotdot_unid_t unid, +@@ -1258,14 +1258,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_wrong_code_entry_limit + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t wrong_code_entry_limit ++ int8_t wrong_code_entry_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_user_code_temporary_disable_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t user_code_temporary_disable_time ++ int8_t user_code_temporary_disable_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_send_pin_over_the_air_callback_t)( + dotdot_unid_t unid, +@@ -1293,7 +1293,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_expiring_user_timeout_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t expiring_user_timeout ++ int16_t expiring_user_timeout + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -1371,42 +1371,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_physical_closed_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t physical_closed_limit_lift ++ int16_t physical_closed_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_physical_closed_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t physical_closed_limit_tilt ++ int16_t physical_closed_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t current_position_lift ++ int16_t current_position_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t current_position_tilt ++ int16_t current_position_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_number_of_actuations_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_actuations_lift ++ int16_t number_of_actuations_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_number_of_actuations_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_actuations_tilt ++ int16_t number_of_actuations_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_config_or_status_callback_t)( + dotdot_unid_t unid, +@@ -1420,63 +1420,63 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_position_lift_percentage ++ int8_t current_position_lift_percentage + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_tilt_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_position_tilt_percentage ++ int8_t current_position_tilt_percentage + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_open_limit_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t installed_open_limit_lift ++ int16_t installed_open_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_closed_limit_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t installed_closed_limit_lift ++ int16_t installed_closed_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_open_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t installed_open_limit_tilt ++ int16_t installed_open_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_closed_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t installed_closed_limit_tilt ++ int16_t installed_closed_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_velocity_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t velocity_lift ++ int16_t velocity_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_acceleration_time_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t acceleration_time_lift ++ int16_t acceleration_time_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_deceleration_time_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t deceleration_time_lift ++ int16_t deceleration_time_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_mode_callback_t)( + dotdot_unid_t unid, +@@ -1490,14 +1490,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_intermediate_set + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- const char* intermediate_setpoints_lift ++ uint8_t intermediate_setpoints_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_intermediate_setpoints_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- const char* intermediate_setpoints_tilt ++ uint8_t intermediate_setpoints_tilt + ); + // Callback types used by the barrier_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_moving_state_callback_t)( +@@ -1526,49 +1526,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_open_events_call + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t open_events ++ int16_t open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_close_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t close_events ++ int16_t close_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_command_open_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t command_open_events ++ int16_t command_open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_command_close_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t command_close_events ++ int16_t command_close_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_open_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t open_period ++ int16_t open_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_close_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t close_period ++ int16_t close_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_barrier_position_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t barrier_position ++ int8_t barrier_position + ); + // Callback types used by the pump_configuration_and_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_pressure_callback_t)( +@@ -1583,14 +1583,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_speed ++ int16_t max_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_flow ++ int16_t max_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_pressure_callback_t)( + dotdot_unid_t unid, +@@ -1625,28 +1625,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_const_speed ++ int16_t min_const_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_const_speed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_const_speed ++ int16_t max_const_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_const_flow ++ int16_t min_const_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_const_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_const_flow ++ int16_t max_const_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_temp_callback_t)( + dotdot_unid_t unid, +@@ -1695,28 +1695,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_s + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t speed ++ int16_t speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_lifetime_running_hours_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t lifetime_running_hours ++ int32_t lifetime_running_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_power_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t power ++ int32_t power + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_lifetime_energy_consumed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t lifetime_energy_consumed ++ int32_t lifetime_energy_consumed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_operation_mode_callback_t)( + dotdot_unid_t unid, +@@ -1794,14 +1794,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_pi_cooling_demand_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t pi_cooling_demand ++ int8_t pi_cooling_demand + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_pi_heating_demand_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t pi_heating_demand ++ int8_t pi_heating_demand + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_hvac_system_type_configuration_callback_t)( + dotdot_unid_t unid, +@@ -1927,14 +1927,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_number_of_weekly_tran + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_weekly_transitions ++ int8_t number_of_weekly_transitions + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_number_of_daily_transitions_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_daily_transitions ++ int8_t number_of_daily_transitions + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_temperature_setpoint_hold_callback_t)( + dotdot_unid_t unid, +@@ -1948,7 +1948,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_temperature_setpoint_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t temperature_setpoint_hold_duration ++ int16_t temperature_setpoint_hold_duration + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_thermostat_programming_operation_mode_callback_t)( + dotdot_unid_t unid, +@@ -1983,56 +1983,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_setpoint_change_sourc + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t setpoint_change_source_timestamp ++ uint8_t setpoint_change_source_timestamp + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t occupied_setback ++ int8_t occupied_setback + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t occupied_setback_min ++ int8_t occupied_setback_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t occupied_setback_max ++ int8_t occupied_setback_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t unoccupied_setback ++ int8_t unoccupied_setback + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t unoccupied_setback_min ++ int8_t unoccupied_setback_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t unoccupied_setback_max ++ int8_t unoccupied_setback_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_emergency_heat_delta_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t emergency_heat_delta ++ int8_t emergency_heat_delta + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_type_callback_t)( + dotdot_unid_t unid, +@@ -2046,7 +2046,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_capacity_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_capacity ++ int16_t ac_capacity + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_refrigerant_type_callback_t)( + dotdot_unid_t unid, +@@ -2111,21 +2111,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relativ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t relative_humidity ++ int8_t relative_humidity + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumidification_cooling_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t dehumidification_cooling ++ int8_t dehumidification_cooling + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_rh_dehumidification_setpoint_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t rh_dehumidification_setpoint ++ int8_t rh_dehumidification_setpoint + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relative_humidity_mode_callback_t)( + dotdot_unid_t unid, +@@ -2146,14 +2146,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumid + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t dehumidification_hysteresis ++ int8_t dehumidification_hysteresis + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumidification_max_cool_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t dehumidification_max_cool ++ int8_t dehumidification_max_cool + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relative_humidity_display_callback_t)( + dotdot_unid_t unid, +@@ -2190,35 +2190,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_current_hue_callba + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_hue ++ int8_t current_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_current_saturation_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_saturation ++ int8_t current_saturation + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_remaining_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t remaining_time ++ int16_t remaining_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_currentx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t currentx ++ int16_t currentx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_currenty_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t currenty ++ int16_t currenty + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_drift_compensation_callback_t)( + dotdot_unid_t unid, +@@ -2239,7 +2239,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temperature_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_temperature_mireds ++ int16_t color_temperature_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_mode_callback_t)( + dotdot_unid_t unid, +@@ -2260,217 +2260,217 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_number_of_primarie + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_primaries ++ int8_t number_of_primaries + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary1x ++ int16_t primary1x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary1y ++ int16_t primary1y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary1_intensity ++ int8_t primary1_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary2x ++ int16_t primary2x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary2y ++ int16_t primary2y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary2_intensity ++ int8_t primary2_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary3x ++ int16_t primary3x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary3y ++ int16_t primary3y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary3_intensity ++ int8_t primary3_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary4x ++ int16_t primary4x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary4y ++ int16_t primary4y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary4_intensity ++ int8_t primary4_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary5x ++ int16_t primary5x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary5y ++ int16_t primary5y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary5_intensity ++ int8_t primary5_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary6x ++ int16_t primary6x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t primary6y ++ int16_t primary6y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t primary6_intensity ++ int8_t primary6_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_white_pointx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t white_pointx ++ int16_t white_pointx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_white_pointy_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t white_pointy ++ int16_t white_pointy + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointrx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointrx ++ int16_t color_pointrx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointry ++ int16_t color_pointry + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointr_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t color_pointr_intensity ++ int8_t color_pointr_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointgx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointgx ++ int16_t color_pointgx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointgy_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointgy ++ int16_t color_pointgy + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointg_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t color_pointg_intensity ++ int8_t color_pointg_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointbx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointbx ++ int16_t color_pointbx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointby_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_pointby ++ int16_t color_pointby + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointb_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t color_pointb_intensity ++ int8_t color_pointb_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_enhanced_current_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t enhanced_current_hue ++ int16_t enhanced_current_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_enhanced_color_mode_callback_t)( + dotdot_unid_t unid, +@@ -2484,35 +2484,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_active_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t color_loop_active ++ int8_t color_loop_active + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_direction_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t color_loop_direction ++ int8_t color_loop_direction + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_loop_time ++ int16_t color_loop_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_start_enhanced_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_loop_start_enhanced_hue ++ int16_t color_loop_start_enhanced_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_stored_enhanced_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_loop_stored_enhanced_hue ++ int16_t color_loop_stored_enhanced_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_capabilities_callback_t)( + dotdot_unid_t unid, +@@ -2526,28 +2526,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temp_physica + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_temp_physical_min_mireds ++ int16_t color_temp_physical_min_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temp_physical_max_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t color_temp_physical_max_mireds ++ int16_t color_temp_physical_max_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_couple_color_temp_to_level_min_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t couple_color_temp_to_level_min_mireds ++ int16_t couple_color_temp_to_level_min_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_start_up_color_temperature_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t start_up_color_temperature_mireds ++ int16_t start_up_color_temperature_mireds + ); + // Callback types used by the ballast_configuration cluster + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_min_level_callback_t)( +@@ -2555,14 +2555,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t physical_min_level ++ int8_t physical_min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t physical_max_level ++ int8_t physical_max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_ballast_status_callback_t)( + dotdot_unid_t unid, +@@ -2576,49 +2576,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_min_level_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t min_level ++ int8_t min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t max_level ++ int8_t max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_power_on_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t power_on_level ++ int8_t power_on_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_power_on_fade_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t power_on_fade_time ++ int16_t power_on_fade_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_intrinsic_ballast_factor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t intrinsic_ballast_factor ++ int8_t intrinsic_ballast_factor + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_ballast_factor_adjustment_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t ballast_factor_adjustment ++ int8_t ballast_factor_adjustment + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t lamp_quantity ++ int8_t lamp_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_type_callback_t)( + dotdot_unid_t unid, +@@ -2639,14 +2639,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_rated + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t lamp_rated_hours ++ int32_t lamp_rated_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_burn_hours_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t lamp_burn_hours ++ int32_t lamp_burn_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_alarm_mode_callback_t)( + dotdot_unid_t unid, +@@ -2660,7 +2660,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_burn_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t lamp_burn_hours_trip_point ++ int32_t lamp_burn_hours_trip_point + ); + // Callback types used by the illuminance_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_measured_value_callback_t)( +@@ -2668,28 +2668,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_measured + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_light_sensor_type_callback_t)( + dotdot_unid_t unid, +@@ -2718,7 +2718,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_illuminance_level_sensing_attribute_illumi + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t illuminance_target_level ++ int16_t illuminance_target_level + ); + // Callback types used by the temperature_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_temperature_measurement_attribute_measured_value_callback_t)( +@@ -2747,7 +2747,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_temperature_measurement_attribute_toleranc + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the pressure_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_measured_value_callback_t)( +@@ -2776,7 +2776,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_tolerance_c + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scaled_value_callback_t)( + dotdot_unid_t unid, +@@ -2804,7 +2804,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scaled_tole + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t scaled_tolerance ++ int16_t scaled_tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scale_callback_t)( + dotdot_unid_t unid, +@@ -2819,28 +2819,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_measured_value_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the relativity_humidity cluster + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback_t)( +@@ -2848,28 +2848,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_measured_val + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the occupancy_sensing cluster + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_occupancy_callback_t)( +@@ -2898,63 +2898,63 @@ typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_occupied_t + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t pir_occupied_to_unoccupied_delay ++ int16_t pir_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t pir_unoccupied_to_occupied_delay ++ int16_t pir_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t pir_unoccupied_to_occupied_threshold ++ int8_t pir_unoccupied_to_occupied_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_occupied_to_unoccupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ultrasonic_occupied_to_unoccupied_delay ++ int16_t ultrasonic_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ultrasonic_unoccupied_to_occupied_delay ++ int16_t ultrasonic_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t ultrasonic_unoccupied_to_occupied_threshold ++ int8_t ultrasonic_unoccupied_to_occupied_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_occupied_to_unoccupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t physical_contact_occupied_to_unoccupied_delay ++ int16_t physical_contact_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t physical_contact_unoccupied_to_occupied_delay ++ int16_t physical_contact_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t physical_contact_unoccupied_to_occupied_threshold ++ int8_t physical_contact_unoccupied_to_occupied_threshold + ); + // Callback types used by the soil_moisture cluster + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_measured_value_callback_t)( +@@ -2962,28 +2962,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_measured_value_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the ph_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_measured_value_callback_t)( +@@ -2991,28 +2991,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_measured_value_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the electrical_conductivity_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_measured_value_callback_t)( +@@ -3020,28 +3020,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attrib + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the wind_speed_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_measured_value_callback_t)( +@@ -3049,28 +3049,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_measured_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t measured_value ++ int16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t min_measured_value ++ int16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_measured_value ++ int16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t tolerance ++ int16_t tolerance + ); + // Callback types used by the carbon_monoxide cluster + typedef sl_status_t (*uic_mqtt_dotdot_carbon_monoxide_attribute_measured_value_callback_t)( +@@ -3193,21 +3193,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_zoneid_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t zoneid ++ int8_t zoneid + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_number_of_zone_sensitivity_levels_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t number_of_zone_sensitivity_levels_supported ++ int8_t number_of_zone_sensitivity_levels_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_current_zone_sensitivity_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_zone_sensitivity_level ++ int8_t current_zone_sensitivity_level + ); + // Callback types used by the iaswd cluster + typedef sl_status_t (*uic_mqtt_dotdot_iaswd_attribute_max_duration_callback_t)( +@@ -3215,7 +3215,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_attribute_max_duration_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t max_duration ++ int16_t max_duration + ); + // Callback types used by the metering cluster + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_delivered_callback_t)( +@@ -3223,21 +3223,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_deliv + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t current_summation_delivered ++ int64_t current_summation_delivered + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_received_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t current_summation_received ++ int64_t current_summation_received + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_delivered_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t current_max_demand_delivered ++ int64_t current_max_demand_delivered + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_received_callback_t)( + dotdot_unid_t unid, +@@ -3258,28 +3258,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_reading_snap_shot_time_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t reading_snap_shot_time ++ uint8_t reading_snap_shot_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_delivered_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t current_max_demand_delivered_time ++ uint8_t current_max_demand_delivered_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_received_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t current_max_demand_received_time ++ uint8_t current_max_demand_received_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_default_update_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t default_update_period ++ int8_t default_update_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_supply_status_callback_t)( + dotdot_unid_t unid, +@@ -3293,14 +3293,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_inlet_energy_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t current_inlet_energy_carrier_summation ++ int64_t current_inlet_energy_carrier_summation + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_outlet_energy_carrier_summation_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t current_outlet_energy_carrier_summation ++ int64_t current_outlet_energy_carrier_summation + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_inlet_temperature_callback_t)( + dotdot_unid_t unid, +@@ -3328,14 +3328,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_multiplier_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t multiplier ++ int32_t multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t divisor ++ int32_t divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_summation_formatting_callback_t)( + dotdot_unid_t unid, +@@ -3476,70 +3476,70 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_voltage_multiplier ++ int16_t dc_voltage_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_voltage_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_voltage_divisor ++ int16_t dc_voltage_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_current_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_current_multiplier ++ int16_t dc_current_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_current_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_current_divisor ++ int16_t dc_current_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_power_multiplier ++ int16_t dc_power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t dc_power_divisor ++ int16_t dc_power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_frequency ++ int16_t ac_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_frequency_min ++ int16_t ac_frequency_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_frequency_max ++ int16_t ac_frequency_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_neutral_current_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t neutral_current ++ int16_t neutral_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_total_active_power_callback_t)( + dotdot_unid_t unid, +@@ -3560,7 +3560,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_total_app + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t total_apparent_power ++ int32_t total_apparent_power + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_measured1st_harmonic_current_callback_t)( + dotdot_unid_t unid, +@@ -3651,28 +3651,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_freque + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_frequency_multiplier ++ int16_t ac_frequency_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_frequency_divisor ++ int16_t ac_frequency_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t power_multiplier ++ int32_t power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t power_divisor ++ int32_t power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_harmonic_current_multiplier_callback_t)( + dotdot_unid_t unid, +@@ -3693,7 +3693,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_curr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t line_current ++ int16_t line_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_callback_t)( + dotdot_unid_t unid, +@@ -3714,42 +3714,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage ++ int16_t rms_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_min ++ int16_t rms_voltage_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_max ++ int16_t rms_voltage_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current ++ int16_t rms_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_min ++ int16_t rms_current_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_max ++ int16_t rms_current_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_callback_t)( + dotdot_unid_t unid, +@@ -3784,7 +3784,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t apparent_power ++ int16_t apparent_power + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_callback_t)( + dotdot_unid_t unid, +@@ -3798,91 +3798,91 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_voltage_measurement_period ++ int16_t average_rms_voltage_measurement_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_over_voltage_counter ++ int16_t average_rms_over_voltage_counter + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_under_voltage_counter ++ int16_t average_rms_under_voltage_counter + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_over_voltage_period ++ int16_t rms_extreme_over_voltage_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_under_voltage_period ++ int16_t rms_extreme_under_voltage_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_sag_period ++ int16_t rms_voltage_sag_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_swell_period ++ int16_t rms_voltage_swell_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_voltage_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_voltage_multiplier ++ int16_t ac_voltage_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_voltage_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_voltage_divisor ++ int16_t ac_voltage_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_current_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_current_multiplier ++ int16_t ac_current_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_current_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_current_divisor ++ int16_t ac_current_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_power_multiplier ++ int16_t ac_power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t ac_power_divisor ++ int16_t ac_power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_overload_alarms_mask_callback_t)( + dotdot_unid_t unid, +@@ -3987,7 +3987,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_curr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t line_current_phb ++ int16_t line_current_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_phb_callback_t)( + dotdot_unid_t unid, +@@ -4008,42 +4008,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_phb ++ int16_t rms_voltage_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_min_phb ++ int16_t rms_voltage_min_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_max_phb ++ int16_t rms_voltage_max_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_phb ++ int16_t rms_current_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_min_phb ++ int16_t rms_current_min_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_max_phb ++ int16_t rms_current_max_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_phb_callback_t)( + dotdot_unid_t unid, +@@ -4078,7 +4078,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t apparent_power_phb ++ int16_t apparent_power_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_phb_callback_t)( + dotdot_unid_t unid, +@@ -4092,56 +4092,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_voltage_measurement_period_phb ++ int16_t average_rms_voltage_measurement_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_over_voltage_counter_phb ++ int16_t average_rms_over_voltage_counter_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_under_voltage_counter_phb ++ int16_t average_rms_under_voltage_counter_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_over_voltage_period_phb ++ int16_t rms_extreme_over_voltage_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_under_voltage_period_phb ++ int16_t rms_extreme_under_voltage_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_sag_period_phb ++ int16_t rms_voltage_sag_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_swell_period_phb ++ int16_t rms_voltage_swell_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_current_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t line_current_phc ++ int16_t line_current_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_phc_callback_t)( + dotdot_unid_t unid, +@@ -4162,42 +4162,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_phc ++ int16_t rms_voltage_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_min_phc ++ int16_t rms_voltage_min_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_max_phc ++ int16_t rms_voltage_max_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_phc ++ int16_t rms_current_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_min_phc ++ int16_t rms_current_min_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_current_max_phc ++ int16_t rms_current_max_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_phc_callback_t)( + dotdot_unid_t unid, +@@ -4232,7 +4232,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t apparent_power_phc ++ int16_t apparent_power_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_phc_callback_t)( + dotdot_unid_t unid, +@@ -4246,49 +4246,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_voltage_measurement_period_phc ++ int16_t average_rms_voltage_measurement_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_over_voltage_counter_phc ++ int16_t average_rms_over_voltage_counter_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_rms_under_voltage_counter_phc ++ int16_t average_rms_under_voltage_counter_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_over_voltage_period_phc ++ int16_t rms_extreme_over_voltage_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_extreme_under_voltage_period_phc ++ int16_t rms_extreme_under_voltage_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_sag_period_phc ++ int16_t rms_voltage_sag_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t rms_voltage_swell_period_phc ++ int16_t rms_voltage_swell_period_phc + ); + // Callback types used by the diagnostics cluster + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_number_of_resets_callback_t)( +@@ -4296,217 +4296,217 @@ typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_number_of_resets_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t number_of_resets ++ int16_t number_of_resets + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_persistent_memory_writes_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t persistent_memory_writes ++ int16_t persistent_memory_writes + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_rx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t mac_rx_bcast ++ int32_t mac_rx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t mac_tx_bcast ++ int32_t mac_tx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_rx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t mac_rx_ucast ++ int32_t mac_rx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t mac_tx_ucast ++ int32_t mac_tx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_retry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mac_tx_ucast_retry ++ int16_t mac_tx_ucast_retry + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_fail_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t mac_tx_ucast_fail ++ int16_t mac_tx_ucast_fail + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_rx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_rx_bcast ++ int16_t aps_rx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_tx_bcast ++ int16_t aps_tx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_rx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_rx_ucast ++ int16_t aps_rx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_success_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_tx_ucast_success ++ int16_t aps_tx_ucast_success + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_retry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_tx_ucast_retry ++ int16_t aps_tx_ucast_retry + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_fail_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_tx_ucast_fail ++ int16_t aps_tx_ucast_fail + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_route_disc_initiated_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t route_disc_initiated ++ int16_t route_disc_initiated + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_added_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t neighbor_added ++ int16_t neighbor_added + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_removed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t neighbor_removed ++ int16_t neighbor_removed + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_stale_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t neighbor_stale ++ int16_t neighbor_stale + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_join_indication_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t join_indication ++ int16_t join_indication + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_child_moved_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t child_moved ++ int16_t child_moved + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_nwkfc_failure_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t nwkfc_failure ++ int16_t nwkfc_failure + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_apsfc_failure_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t apsfc_failure ++ int16_t apsfc_failure + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_unauthorized_key_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_unauthorized_key ++ int16_t aps_unauthorized_key + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_nwk_decrypt_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t nwk_decrypt_failures ++ int16_t nwk_decrypt_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_decrypt_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t aps_decrypt_failures ++ int16_t aps_decrypt_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_packet_buffer_allocate_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t packet_buffer_allocate_failures ++ int16_t packet_buffer_allocate_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_relayed_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t relayed_ucast ++ int16_t relayed_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_phy_to_mac_queue_limit_reached_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t phy_to_mac_queue_limit_reached ++ int16_t phy_to_mac_queue_limit_reached + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_packet_validate_drop_count_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t packet_validate_drop_count ++ int16_t packet_validate_drop_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_average_mac_retry_per_aps_message_sent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint16_t average_mac_retry_per_aps_message_sent ++ int16_t average_mac_retry_per_aps_message_sent + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_last_messagelqi_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t last_messagelqi ++ int8_t last_messagelqi + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_last_messagerssi_callback_t)( + dotdot_unid_t unid, +@@ -4537,7 +4537,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_endpoint_id_list_callback_ + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, + size_t endpoint_id_list_count, +- const uint8_t* endpoint_id_list ++ const int8_t* endpoint_id_list + ); + typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_network_status_callback_t)( + dotdot_unid_t unid, +@@ -4558,7 +4558,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_maximum_command_delay_call + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t maximum_command_delay ++ int32_t maximum_command_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_network_list_callback_t)( + dotdot_unid_t unid, +@@ -4598,7 +4598,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_reporting_interva + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t reporting_interval_seconds ++ int32_t reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_cpu_usage_percent_callback_t)( + dotdot_unid_t unid, +@@ -4740,7 +4740,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_uptime_minutes_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t uptime_minutes ++ int64_t uptime_minutes + ); + typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_current_temperature_celcius_callback_t)( + dotdot_unid_t unid, +@@ -4789,7 +4789,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_system_interrupts + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t system_interrupts ++ int64_t system_interrupts + ); + // Callback types used by the application_monitoring cluster + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_application_name_callback_t)( +@@ -4826,14 +4826,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_uptime_mi + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t uptime_minutes ++ int64_t uptime_minutes + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_process_id_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t process_id ++ int64_t process_id + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_hostname_callback_t)( + dotdot_unid_t unid, +@@ -4868,28 +4868,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_stat + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t mqtt_statistics_reporting_interval_seconds ++ int32_t mqtt_statistics_reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_messages_sent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t mqtt_messages_sent ++ int64_t mqtt_messages_sent + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_messages_received_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t mqtt_messages_received ++ int64_t mqtt_messages_received + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_subscription_count_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint64_t mqtt_subscription_count ++ int64_t mqtt_subscription_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_average_delivery_time_seconds_callback_t)( + dotdot_unid_t unid, +@@ -4917,7 +4917,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_applicati + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint32_t application_statistics_reporting_interval_seconds ++ int32_t application_statistics_reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_application_cpu_usage_percent_callback_t)( + dotdot_unid_t unid, +@@ -4978,6 +4978,63 @@ typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_attribute_configu + size_t configuration_parameters_count, + const ConfigurationParameter* configuration_parameters + ); ++// Callback types used by the user_credential cluster ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ int16_t supported_user_unique_identifiers ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ uint8_t supported_credential_rules ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ uint16_t supported_credential_types ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ uint16_t supported_user_types ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ bool support_credential_checksum ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ bool support_admin_pin_code ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ bool support_admin_pin_code_deactivation ++); ++typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_t)( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ bool unretained, ++ uic_mqtt_dotdot_attribute_update_type_t update_type, ++ const char* admin_pin_code ++); + // Callback types used by the protocol_controller_network_management cluster + typedef sl_status_t (*uic_mqtt_dotdot_protocol_controller_network_management_attribute_network_management_state_callback_t)( + dotdot_unid_t unid, +@@ -5101,7 +5158,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_humidifie + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t humidifier_setpoint_precision ++ int8_t humidifier_setpoint_precision + ); + typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_dehumidifier_setpoint_min_callback_t)( + dotdot_unid_t unid, +@@ -5136,7 +5193,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_dehumidif + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t dehumidifier_setpoint_precision ++ int8_t dehumidifier_setpoint_precision + ); + typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_auto_setpoint_min_callback_t)( + dotdot_unid_t unid, +@@ -5171,7 +5228,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_auto_setp + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t auto_setpoint_precision ++ int8_t auto_setpoint_precision + ); + + #ifdef __cplusplus +@@ -9739,6 +9796,62 @@ sl_status_t uic_mqtt_dotdot_configuration_parameters_attributes_init(); + void uic_mqtt_dotdot_configuration_parameters_attribute_configuration_parameters_callback_set(const uic_mqtt_dotdot_configuration_parameters_attribute_configuration_parameters_callback_t callback); + + ++/** ++ * Initializes the attributes features for the UserCredential cluster, ++ * allowing to receive attribute updates from other UNIDs. ++ */ ++sl_status_t uic_mqtt_dotdot_user_credential_attributes_init(); ++ ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/supported_user_unique_identifiers/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/supported_credential_rules/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/supported_credential_types/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/supported_user_types/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/support_credential_checksum/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/support_admin_pin_code/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/support_admin_pin_code_deactivation/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_t callback); ++/** ++ * Setup callback to be called when a ++ * UserCredential/Attributes/admin_pin_code/# is received. Setting ++ * this callback will overwrite the previous set callback ++ */ ++void uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_t callback); ++ ++ + /** + * Initializes the attributes features for the ProtocolController-NetworkManagement cluster, + * allowing to receive attribute updates from other UNIDs. +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_generated_commands.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_generated_commands.h +index 011a75ddf9..96e33e47d2 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_generated_commands.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_generated_commands.h +@@ -4838,6 +4838,428 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_write_attributes + uic_mqtt_dotdot_configuration_parameters_updated_state_t attribute_list + ); + ++/** ++ * @brief Publishes an incoming/generated AddUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_add_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated ModifyUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeleteUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated AddCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_add_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated ModifyCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeleteCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeleteAllUsers command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllUsers ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_users_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++); ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentials command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentials ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++); ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsByType command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsByType ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStartAdd command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartAdd ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_add_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStartModify command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartModify ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_modify_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStop command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStop ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_stop_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++); ++/** ++ * @brief Publishes an incoming/generated CredentialAssociation command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialAssociation ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_association_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated GetUserChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetUserChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_user_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated GetCredentialChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetCredentialChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_credential_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated GetAllUsersChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetAllUsersChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_all_users_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++); ++/** ++ * @brief Publishes an incoming/generated SetAdminPINCode command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/SetAdminPINCode ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_set_admin_pin_code_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++); ++/** ++ * @brief Publishes an incoming/generated DeactivateAdminPINCode command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeactivateAdminPINCode ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_deactivate_admin_pin_code_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++); ++ ++/** ++ * @brief Publishes an incoming/generated WriteAttributes command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/WriteAttributes ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * @param attribute_values Values to assign to the attributes ++ * @param attribute_list List of attributes that are written ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_write_attributes_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_user_credential_state_t attribute_values, ++ uic_mqtt_dotdot_user_credential_updated_state_t attribute_list ++); ++ + /** + * @brief Publishes an incoming/generated Write command for + * the ProtocolController-NetworkManagement cluster. +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_group_commands.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_group_commands.h +index ac85664a4f..e052483320 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_group_commands.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_group_commands.h +@@ -3610,6 +3610,338 @@ void uic_mqtt_dotdot_by_group_configuration_parameters_write_attributes_callback + + + ++/** ++ * @brief Callback signature for by-group UserCredential::AddUser command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_add_user_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/add_user is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_add_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_add_user_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::ModifyUser command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/modify_user is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteUser command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_user is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::AddCredential command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/add_credential is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::ModifyCredential command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/modify_credential is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteCredential command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_credential is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteAllUsers command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_t)( ++ const dotdot_group_id_t group_id ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_all_users is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteAllCredentials command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_t)( ++ const dotdot_group_id_t group_id ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_all_credentials is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteAllCredentialsByType command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_all_credentials_by_type is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteAllCredentialsForUser command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_all_credentials_for_user is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeleteAllCredentialsForUserByType command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/delete_all_credentials_for_user_by_type is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::CredentialLearnStartAdd command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/credential_learn_start_add is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::CredentialLearnStartModify command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/credential_learn_start_modify is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::CredentialLearnStop command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_t)( ++ const dotdot_group_id_t group_id ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/credential_learn_stop is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::CredentialAssociation command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/credential_association is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::GetUserChecksum command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/get_user_checksum is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::GetCredentialChecksum command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/get_credential_checksum is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::GetAllUsersChecksum command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_t)( ++ const dotdot_group_id_t group_id ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/get_all_users_checksum is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::SetAdminPINCode command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_t)( ++ const dotdot_group_id_t group_id, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/set_admin_pin_code is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_t callback); ++ ++/** ++ * @brief Callback signature for by-group UserCredential::DeactivateAdminPINCode command. ++ */ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_t)( ++ const dotdot_group_id_t group_id ++); ++ ++/** ++ * Setup handler to be called when a ++ * ucl/by-group/+/UserCredential/deactivate_admin_pin_code is received. ++ * Setting this callback will overwrite the previous set callback. ++ * ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_t callback); ++ ++typedef void (*uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_t)( ++ const dotdot_group_id_t group_id, ++ uic_mqtt_dotdot_user_credential_state_t, ++ uic_mqtt_dotdot_user_credential_updated_state_t ++); ++ ++/** ++ * Setup a callback for WriteAttribute to be called when a ++ * ucl/by-group/+/user_credential/Commands/WriteAttributes is received. ++ * Setting this callback will overwrite any previously set callback. ++ */ ++void uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_set( ++ const uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_t callback ++); ++ ++ ++ + typedef void (*uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback_t)( + const dotdot_group_id_t group_id, + uic_mqtt_dotdot_descriptor_state_t, +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.h +index 80d87abc45..bec991c7cf 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.h +@@ -216,6 +216,20 @@ char *commissioning_startup_control_get_enum_value_name_c( + uint32_t value, char *result, size_t max_result_size); + /** Get commissioning_startup_control enum representation from string. */ + uint32_t commissioning_startup_control_get_enum_value_number_c(const char *str); ++#define CRED_RULE_ENUM_NAME_AVAILABLE 1 ++ ++/** Get cred_rule string representation from enum. */ ++char *cred_rule_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size); ++/** Get cred_rule enum representation from string. */ ++uint32_t cred_rule_get_enum_value_number_c(const char *str); ++#define CRED_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** Get cred_type string representation from enum. */ ++char *cred_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size); ++/** Get cred_type enum representation from string. */ ++uint32_t cred_type_get_enum_value_number_c(const char *str); + #define CREDENTIAL_RULE_ENUM_ENUM_NAME_AVAILABLE 1 + + /** Get credential_rule_enum string representation from enum. */ +@@ -860,6 +874,27 @@ char *unify_thermostat_thermostat_mode_get_enum_value_name_c( + uint32_t value, char *result, size_t max_result_size); + /** Get unify_thermostat_thermostat_mode enum representation from string. */ + uint32_t unify_thermostat_thermostat_mode_get_enum_value_number_c(const char *str); ++#define USER_MODIFIER_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** Get user_modifier_type string representation from enum. */ ++char *user_modifier_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size); ++/** Get user_modifier_type enum representation from string. */ ++uint32_t user_modifier_type_get_enum_value_number_c(const char *str); ++#define USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** Get user_name_encoding_type string representation from enum. */ ++char *user_name_encoding_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size); ++/** Get user_name_encoding_type enum representation from string. */ ++uint32_t user_name_encoding_type_get_enum_value_number_c(const char *str); ++#define USER_TYPE_ENUM_ENUM_NAME_AVAILABLE 1 ++ ++/** Get user_type_enum string representation from enum. */ ++char *user_type_enum_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size); ++/** Get user_type_enum enum representation from string. */ ++uint32_t user_type_enum_get_enum_value_number_c(const char *str); + #define WINDOW_COVERING_WINDOW_COVERING_TYPE_ENUM_NAME_AVAILABLE 1 + + /** Get window_covering_window_covering_type string representation from enum. */ +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.hpp b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.hpp +index 14befa43ce..14e4a8f211 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.hpp ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_helpers.hpp +@@ -489,6 +489,40 @@ std::string commissioning_startup_control_get_enum_value_name( + */ + uint32_t commissioning_startup_control_get_enum_value_number(const std::string &str); + ++#define CRED_RULE_ENUM_NAME_AVAILABLE 1 ++ ++/** ++ * @brief Finds the name of a field for the CredRule enum ++ * ++ * @returns A string representation of the value. ++ */ ++std::string cred_rule_get_enum_value_name( ++ uint32_t value); ++ ++/** ++ * @brief Finds the enum number of a string representation for the CredRule enum ++ * ++ * @returns A number enum value. ++ */ ++uint32_t cred_rule_get_enum_value_number(const std::string &str); ++ ++#define CRED_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** ++ * @brief Finds the name of a field for the CredType enum ++ * ++ * @returns A string representation of the value. ++ */ ++std::string cred_type_get_enum_value_name( ++ uint32_t value); ++ ++/** ++ * @brief Finds the enum number of a string representation for the CredType enum ++ * ++ * @returns A number enum value. ++ */ ++uint32_t cred_type_get_enum_value_number(const std::string &str); ++ + #define CREDENTIAL_RULE_ENUM_ENUM_NAME_AVAILABLE 1 + + /** +@@ -2053,6 +2087,57 @@ std::string unify_thermostat_thermostat_mode_get_enum_value_name( + */ + uint32_t unify_thermostat_thermostat_mode_get_enum_value_number(const std::string &str); + ++#define USER_MODIFIER_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** ++ * @brief Finds the name of a field for the UserModifierType enum ++ * ++ * @returns A string representation of the value. ++ */ ++std::string user_modifier_type_get_enum_value_name( ++ uint32_t value); ++ ++/** ++ * @brief Finds the enum number of a string representation for the UserModifierType enum ++ * ++ * @returns A number enum value. ++ */ ++uint32_t user_modifier_type_get_enum_value_number(const std::string &str); ++ ++#define USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE 1 ++ ++/** ++ * @brief Finds the name of a field for the UserNameEncodingType enum ++ * ++ * @returns A string representation of the value. ++ */ ++std::string user_name_encoding_type_get_enum_value_name( ++ uint32_t value); ++ ++/** ++ * @brief Finds the enum number of a string representation for the UserNameEncodingType enum ++ * ++ * @returns A number enum value. ++ */ ++uint32_t user_name_encoding_type_get_enum_value_number(const std::string &str); ++ ++#define USER_TYPE_ENUM_ENUM_NAME_AVAILABLE 1 ++ ++/** ++ * @brief Finds the name of a field for the UserTypeEnum enum ++ * ++ * @returns A string representation of the value. ++ */ ++std::string user_type_enum_get_enum_value_name( ++ uint32_t value); ++ ++/** ++ * @brief Finds the enum number of a string representation for the UserTypeEnum enum ++ * ++ * @returns A number enum value. ++ */ ++uint32_t user_type_enum_get_enum_value_number(const std::string &str); ++ + #define WINDOW_COVERING_WINDOW_COVERING_TYPE_ENUM_NAME_AVAILABLE 1 + + /** +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_send_commands.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_send_commands.h +index b49b9a5c1a..3d8d69ac9e 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_send_commands.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_send_commands.h +@@ -7010,6 +7010,746 @@ void uic_mqtt_dotdot_configuration_parameters_publish_discover_parameter_range_c + const uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t *fields + + ); ++/** ++ * @brief Sends/Publishes a AddUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/AddUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a AddUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/AddUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a ModifyUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/ModifyUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a ModifyUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/ModifyUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeleteUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a AddCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/AddCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a AddCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/AddCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a ModifyCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/ModifyCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a ModifyCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/ModifyCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeleteCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeleteAllUsers command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllUsers ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_users_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteAllUsers command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllUsers ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_users_command_to_group( ++ uint16_t destination_group_id ++); ++/** ++ * @brief Sends/Publishes a DeleteAllCredentials command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentials ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentials command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentials ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_command_to_group( ++ uint16_t destination_group_id ++); ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsByType command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsByType ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_by_type_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsByType command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsByType ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_by_type_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsForUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsForUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsForUserByType ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_by_type_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsForUserByType ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_by_type_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a CredentialLearnStartAdd command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStartAdd ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_add_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartAdd command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStartAdd ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_add_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a CredentialLearnStartModify command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStartModify ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_modify_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartModify command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStartModify ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_modify_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a CredentialLearnStop command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStop ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_stop_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++); ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStop command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStop ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_stop_command_to_group( ++ uint16_t destination_group_id ++); ++/** ++ * @brief Sends/Publishes a CredentialAssociation command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialAssociation ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_association_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a CredentialAssociation command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialAssociation ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_association_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a GetUserChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetUserChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_user_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a GetUserChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetUserChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_user_checksum_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a GetCredentialChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetCredentialChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_credential_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a GetCredentialChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetCredentialChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_credential_checksum_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a GetAllUsersChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetAllUsersChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_all_users_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++); ++ ++/** ++ * @brief Sends/Publishes a GetAllUsersChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetAllUsersChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_all_users_checksum_command_to_group( ++ uint16_t destination_group_id ++); ++/** ++ * @brief Sends/Publishes a SetAdminPINCode command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/SetAdminPINCode ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_set_admin_pin_code_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++); ++ ++/** ++ * @brief Sends/Publishes a SetAdminPINCode command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/SetAdminPINCode ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_set_admin_pin_code_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++); ++/** ++ * @brief Sends/Publishes a DeactivateAdminPINCode command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeactivateAdminPINCode ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_deactivate_admin_pin_code_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++); ++ ++/** ++ * @brief Sends/Publishes a DeactivateAdminPINCode command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeactivateAdminPINCode ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_deactivate_admin_pin_code_command_to_group( ++ uint16_t destination_group_id ++); + /** + * @brief Sends/Publishes a Write command for + * the ProtocolController-NetworkManagement cluster to a destination. +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_supported_generated_commands.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_supported_generated_commands.h +index 3ee01c0c62..4c1c15b4eb 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_supported_generated_commands.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_supported_generated_commands.h +@@ -1552,6 +1552,54 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_generated_comman + ); + + ++/** ++ * @brief Struct containing the list of commands for UserCredential ++ */ ++typedef struct _uic_mqtt_dotdot_user_credential_supported_commands_ { ++ bool add_user; ++ bool modify_user; ++ bool delete_user; ++ bool add_credential; ++ bool modify_credential; ++ bool delete_credential; ++ bool delete_all_users; ++ bool delete_all_credentials; ++ bool delete_all_credentials_by_type; ++ bool delete_all_credentials_for_user; ++ bool delete_all_credentials_for_user_by_type; ++ bool credential_learn_start_add; ++ bool credential_learn_start_modify; ++ bool credential_learn_stop; ++ bool credential_association; ++ bool get_user_checksum; ++ bool get_credential_checksum; ++ bool get_all_users_checksum; ++ bool set_admin_pin_code; ++ bool deactivate_admin_pin_code; ++ bool write_attributes; ++} uic_mqtt_dotdot_user_credential_supported_commands_t; ++ ++/** ++ * @brief Sends/Publishes a the SupportedGenerated commands for ++ * the UserCredential cluster for a UNID/Endpoint ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/SupportedGeneratedCommands ++ * ++ * @param unid The UNID of the node on behalf of which the advertisment is made ++ * ++ * @param endpoint The Endpoint ID of the node on behalf of which the advertisment is made ++ * ++ * @param command_list Struct pointer with the fields value indicating if ++ * individual commands can be generated. ++ */ ++void uic_mqtt_dotdot_user_credential_publish_supported_generated_commands( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_supported_commands_t *command_list ++); ++ ++ + /** + * @brief Struct containing the list of commands for ProtocolController-NetworkManagement + */ +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp +index d1122bf8dd..8e00af65dd 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp +@@ -394,7 +394,7 @@ static void uic_mqtt_dotdot_on_basic_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_basic_zcl_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -464,7 +464,7 @@ sl_status_t uic_mqtt_dotdot_basic_zcl_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_application_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -534,7 +534,7 @@ sl_status_t uic_mqtt_dotdot_basic_application_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_stack_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -604,7 +604,7 @@ sl_status_t uic_mqtt_dotdot_basic_stack_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_hw_version_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -1091,7 +1091,7 @@ sl_status_t uic_mqtt_dotdot_basic_generic_device_type_unretain( + + sl_status_t uic_mqtt_dotdot_basic_product_code_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2144,7 +2144,7 @@ static void uic_mqtt_dotdot_on_power_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2214,7 +2214,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2353,7 +2353,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2423,7 +2423,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2493,7 +2493,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2563,7 +2563,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2633,7 +2633,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2842,7 +2842,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2912,7 +2912,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2982,7 +2982,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3121,7 +3121,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3191,7 +3191,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3261,7 +3261,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3331,7 +3331,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3401,7 +3401,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3471,7 +3471,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3541,7 +3541,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3611,7 +3611,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3750,7 +3750,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_state_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3820,7 +3820,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4029,7 +4029,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4099,7 +4099,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4169,7 +4169,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4308,7 +4308,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4378,7 +4378,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4448,7 +4448,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4518,7 +4518,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4588,7 +4588,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4658,7 +4658,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshol + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4728,7 +4728,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4798,7 +4798,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4937,7 +4937,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_state_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5007,7 +5007,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5216,7 +5216,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5286,7 +5286,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5356,7 +5356,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5495,7 +5495,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5565,7 +5565,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5635,7 +5635,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5705,7 +5705,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5775,7 +5775,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5845,7 +5845,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshol + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5915,7 +5915,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5985,7 +5985,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6540,7 +6540,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_max_temp_experience + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6819,7 +6819,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_threshold + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6889,7 +6889,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -7185,7 +7185,7 @@ void uic_mqtt_dotdot_on_identify_identify( + return; + } + +- uint16_t identify_time = {}; ++ int16_t identify_time = {}; + + + nlohmann::json jsn; +@@ -7244,7 +7244,7 @@ static void uic_mqtt_dotdot_on_generated_identify_identify( + return; + } + +- uint16_t identify_time = {}; ++ int16_t identify_time = {}; + + + nlohmann::json jsn; +@@ -7304,7 +7304,7 @@ void uic_mqtt_dotdot_on_identify_identify_query_response( + return; + } + +- uint16_t timeout = {}; ++ int16_t timeout = {}; + + + nlohmann::json jsn; +@@ -7363,7 +7363,7 @@ static void uic_mqtt_dotdot_on_generated_identify_identify_query_response( + return; + } + +- uint16_t timeout = {}; ++ int16_t timeout = {}; + + + nlohmann::json jsn; +@@ -7759,7 +7759,7 @@ static void uic_mqtt_dotdot_on_identify_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_identify_identify_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -8297,7 +8297,7 @@ void uic_mqtt_dotdot_on_groups_add_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -8361,7 +8361,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -8427,7 +8427,7 @@ void uic_mqtt_dotdot_on_groups_add_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8491,7 +8491,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8555,7 +8555,7 @@ void uic_mqtt_dotdot_on_groups_view_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8614,7 +8614,7 @@ static void uic_mqtt_dotdot_on_generated_groups_view_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8675,7 +8675,7 @@ void uic_mqtt_dotdot_on_groups_view_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -8744,7 +8744,7 @@ static void uic_mqtt_dotdot_on_generated_groups_view_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -8813,7 +8813,7 @@ void uic_mqtt_dotdot_on_groups_get_group_membership( + return; + } + +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8873,7 +8873,7 @@ static void uic_mqtt_dotdot_on_generated_groups_get_group_membership( + return; + } + +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8934,8 +8934,8 @@ void uic_mqtt_dotdot_on_groups_get_group_membership_response( + return; + } + +- uint8_t capacity = {}; +- std::vector group_list; ++ int8_t capacity = {}; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8999,8 +8999,8 @@ static void uic_mqtt_dotdot_on_generated_groups_get_group_membership_response( + return; + } + +- uint8_t capacity = {}; +- std::vector group_list; ++ int8_t capacity = {}; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -9065,7 +9065,7 @@ void uic_mqtt_dotdot_on_groups_remove_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9124,7 +9124,7 @@ static void uic_mqtt_dotdot_on_generated_groups_remove_group( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9185,7 +9185,7 @@ void uic_mqtt_dotdot_on_groups_remove_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9249,7 +9249,7 @@ static void uic_mqtt_dotdot_on_generated_groups_remove_group_response( + } + + uint8_t status = {}; +- uint16_t group_id = {}; ++ int16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9416,7 +9416,7 @@ void uic_mqtt_dotdot_on_groups_add_group_if_identifying( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -9480,7 +9480,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group_if_identifying( + return; + } + +- uint16_t group_id = {}; ++ int16_t group_id = {}; + std::string group_name; + + +@@ -10549,12 +10549,12 @@ void uic_mqtt_dotdot_on_scenes_add_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; +- uint8_t transition_time100ms = {}; ++ int8_t transition_time100ms = {}; + + + nlohmann::json jsn; +@@ -10634,12 +10634,12 @@ static void uic_mqtt_dotdot_on_generated_scenes_add_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; +- uint8_t transition_time100ms = {}; ++ int8_t transition_time100ms = {}; + + + nlohmann::json jsn; +@@ -10721,8 +10721,8 @@ void uic_mqtt_dotdot_on_scenes_add_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10790,8 +10790,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_add_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10859,8 +10859,8 @@ void uic_mqtt_dotdot_on_scenes_view_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10923,8 +10923,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_view_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10989,9 +10989,9 @@ void uic_mqtt_dotdot_on_scenes_view_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -11074,9 +11074,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_view_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -11159,8 +11159,8 @@ void uic_mqtt_dotdot_on_scenes_remove_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11223,8 +11223,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11289,8 +11289,8 @@ void uic_mqtt_dotdot_on_scenes_remove_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11358,8 +11358,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11427,7 +11427,7 @@ void uic_mqtt_dotdot_on_scenes_remove_all_scenes( + return; + } + +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -11486,7 +11486,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_all_scenes( + return; + } + +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -11547,7 +11547,7 @@ void uic_mqtt_dotdot_on_scenes_remove_all_scenes_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -11611,7 +11611,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_all_scenes_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -11675,8 +11675,8 @@ void uic_mqtt_dotdot_on_scenes_store_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11739,8 +11739,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_store_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11805,8 +11805,8 @@ void uic_mqtt_dotdot_on_scenes_store_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11874,8 +11874,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_store_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11943,9 +11943,9 @@ void uic_mqtt_dotdot_on_scenes_recall_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + + + nlohmann::json jsn; +@@ -12012,9 +12012,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_recall_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + + + nlohmann::json jsn; +@@ -12082,7 +12082,7 @@ void uic_mqtt_dotdot_on_scenes_get_scene_membership( + return; + } + +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -12141,7 +12141,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_get_scene_membership( + return; + } + +- uint16_t groupid = {}; ++ uint8_t * groupid = {}; + + + nlohmann::json jsn; +@@ -12202,9 +12202,9 @@ void uic_mqtt_dotdot_on_scenes_get_scene_membership_response( + } + + zclStatus status = {}; +- uint8_t capacity = {}; +- uint16_t groupid = {}; +- std::vector scene_list; ++ int8_t capacity = {}; ++ uint8_t * groupid = {}; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -12277,9 +12277,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_get_scene_membership_response( + } + + zclStatus status = {}; +- uint8_t capacity = {}; +- uint16_t groupid = {}; +- std::vector scene_list; ++ int8_t capacity = {}; ++ uint8_t * groupid = {}; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -12352,9 +12352,9 @@ void uic_mqtt_dotdot_on_scenes_enhanced_add_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12432,9 +12432,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_add_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12514,8 +12514,8 @@ void uic_mqtt_dotdot_on_scenes_enhanced_add_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12583,8 +12583,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_add_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12652,8 +12652,8 @@ void uic_mqtt_dotdot_on_scenes_enhanced_view_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12716,8 +12716,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_view_scene( + return; + } + +- uint16_t groupid = {}; +- uint8_t sceneid = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12782,9 +12782,9 @@ void uic_mqtt_dotdot_on_scenes_enhanced_view_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12867,9 +12867,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_view_scene_response( + } + + zclStatus status = {}; +- uint16_t groupid = {}; +- uint8_t sceneid = {}; +- uint16_t transition_time = {}; ++ uint8_t * groupid = {}; ++ int8_t sceneid = {}; ++ int16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12953,10 +12953,10 @@ void uic_mqtt_dotdot_on_scenes_copy_scene( + } + + uint8_t mode = {}; +- uint16_t group_identifier_from = {}; +- uint8_t scene_identifier_from = {}; +- uint16_t group_identifier_to = {}; +- uint8_t scene_identifier_to = {}; ++ uint8_t * group_identifier_from = {}; ++ int8_t scene_identifier_from = {}; ++ uint8_t * group_identifier_to = {}; ++ int8_t scene_identifier_to = {}; + + + nlohmann::json jsn; +@@ -13032,10 +13032,10 @@ static void uic_mqtt_dotdot_on_generated_scenes_copy_scene( + } + + uint8_t mode = {}; +- uint16_t group_identifier_from = {}; +- uint8_t scene_identifier_from = {}; +- uint16_t group_identifier_to = {}; +- uint8_t scene_identifier_to = {}; ++ uint8_t * group_identifier_from = {}; ++ int8_t scene_identifier_from = {}; ++ uint8_t * group_identifier_to = {}; ++ int8_t scene_identifier_to = {}; + + + nlohmann::json jsn; +@@ -13112,8 +13112,8 @@ void uic_mqtt_dotdot_on_scenes_copy_scene_response( + } + + zclStatus status = {}; +- uint16_t group_identifier_from = {}; +- uint8_t scene_identifier_from = {}; ++ uint8_t * group_identifier_from = {}; ++ int8_t scene_identifier_from = {}; + + + nlohmann::json jsn; +@@ -13181,8 +13181,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_copy_scene_response( + } + + zclStatus status = {}; +- uint16_t group_identifier_from = {}; +- uint8_t scene_identifier_from = {}; ++ uint8_t * group_identifier_from = {}; ++ int8_t scene_identifier_from = {}; + + + nlohmann::json jsn; +@@ -13366,7 +13366,7 @@ static void uic_mqtt_dotdot_on_scenes_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_scenes_scene_count_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -13436,7 +13436,7 @@ sl_status_t uic_mqtt_dotdot_scenes_scene_count_unretain( + + sl_status_t uic_mqtt_dotdot_scenes_current_scene_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -13506,7 +13506,7 @@ sl_status_t uic_mqtt_dotdot_scenes_current_scene_unretain( + + sl_status_t uic_mqtt_dotdot_scenes_current_group_publish( + const char *base_topic, +- uint16_t value, ++ uint8_t * value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -14623,7 +14623,7 @@ void uic_mqtt_dotdot_on_on_off_off_with_effect( + } + + OffWithEffectEffectIdentifier effect_identifier = {}; +- uint8_t effect_variant = {}; ++ int8_t effect_variant = {}; + + + nlohmann::json jsn; +@@ -14687,7 +14687,7 @@ static void uic_mqtt_dotdot_on_generated_on_off_off_with_effect( + } + + OffWithEffectEffectIdentifier effect_identifier = {}; +- uint8_t effect_variant = {}; ++ int8_t effect_variant = {}; + + + nlohmann::json jsn; +@@ -14855,8 +14855,8 @@ void uic_mqtt_dotdot_on_on_off_on_with_timed_off( + } + + uint8_t on_off_control = {}; +- uint16_t on_time = {}; +- uint16_t off_wait_time = {}; ++ int16_t on_time = {}; ++ int16_t off_wait_time = {}; + + + nlohmann::json jsn; +@@ -14924,8 +14924,8 @@ static void uic_mqtt_dotdot_on_generated_on_off_on_with_timed_off( + } + + uint8_t on_off_control = {}; +- uint16_t on_time = {}; +- uint16_t off_wait_time = {}; ++ int16_t on_time = {}; ++ int16_t off_wait_time = {}; + + + nlohmann::json jsn; +@@ -15245,7 +15245,7 @@ sl_status_t uic_mqtt_dotdot_on_off_global_scene_control_unretain( + + sl_status_t uic_mqtt_dotdot_on_off_on_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -15315,7 +15315,7 @@ sl_status_t uic_mqtt_dotdot_on_off_on_time_unretain( + + sl_status_t uic_mqtt_dotdot_on_off_off_wait_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -15907,8 +15907,8 @@ void uic_mqtt_dotdot_on_level_move_to_level( + return; + } + +- uint8_t level = {}; +- uint16_t transition_time = {}; ++ int8_t level = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -15981,8 +15981,8 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_level( + return; + } + +- uint8_t level = {}; +- uint16_t transition_time = {}; ++ int8_t level = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16057,7 +16057,7 @@ void uic_mqtt_dotdot_on_level_move( + } + + MoveStepMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16131,7 +16131,7 @@ static void uic_mqtt_dotdot_on_generated_level_move( + } + + MoveStepMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16206,8 +16206,8 @@ void uic_mqtt_dotdot_on_level_step( + } + + MoveStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint16_t transition_time = {}; ++ int8_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16285,8 +16285,8 @@ static void uic_mqtt_dotdot_on_generated_level_step( + } + + MoveStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint16_t transition_time = {}; ++ int8_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16493,8 +16493,8 @@ void uic_mqtt_dotdot_on_level_move_to_level_with_on_off( + return; + } + +- uint8_t level = {}; +- uint16_t transition_time = {}; ++ int8_t level = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16567,8 +16567,8 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_level_with_on_off( + return; + } + +- uint8_t level = {}; +- uint16_t transition_time = {}; ++ int8_t level = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16643,7 +16643,7 @@ void uic_mqtt_dotdot_on_level_move_with_on_off( + } + + MoveStepMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16717,7 +16717,7 @@ static void uic_mqtt_dotdot_on_generated_level_move_with_on_off( + } + + MoveStepMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16792,8 +16792,8 @@ void uic_mqtt_dotdot_on_level_step_with_on_off( + } + + MoveStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint16_t transition_time = {}; ++ int8_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16871,8 +16871,8 @@ static void uic_mqtt_dotdot_on_generated_level_step_with_on_off( + } + + MoveStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint16_t transition_time = {}; ++ int8_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -17079,7 +17079,7 @@ void uic_mqtt_dotdot_on_level_move_to_closest_frequency( + return; + } + +- uint16_t frequency = {}; ++ int16_t frequency = {}; + + + nlohmann::json jsn; +@@ -17138,7 +17138,7 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_closest_frequency( + return; + } + +- uint16_t frequency = {}; ++ int16_t frequency = {}; + + + nlohmann::json jsn; +@@ -17328,7 +17328,7 @@ static void uic_mqtt_dotdot_on_level_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_level_current_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17398,7 +17398,7 @@ sl_status_t uic_mqtt_dotdot_level_current_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_remaining_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17468,7 +17468,7 @@ sl_status_t uic_mqtt_dotdot_level_remaining_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17538,7 +17538,7 @@ sl_status_t uic_mqtt_dotdot_level_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17608,7 +17608,7 @@ sl_status_t uic_mqtt_dotdot_level_max_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_current_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17678,7 +17678,7 @@ sl_status_t uic_mqtt_dotdot_level_current_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_level_min_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17748,7 +17748,7 @@ sl_status_t uic_mqtt_dotdot_level_min_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_level_max_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17887,7 +17887,7 @@ sl_status_t uic_mqtt_dotdot_level_options_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17957,7 +17957,7 @@ sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18027,7 +18027,7 @@ sl_status_t uic_mqtt_dotdot_level_on_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18097,7 +18097,7 @@ sl_status_t uic_mqtt_dotdot_level_on_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_off_transition_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18167,7 +18167,7 @@ sl_status_t uic_mqtt_dotdot_level_off_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_default_move_rate_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18237,7 +18237,7 @@ sl_status_t uic_mqtt_dotdot_level_default_move_rate_unretain( + + sl_status_t uic_mqtt_dotdot_level_start_up_current_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18676,7 +18676,7 @@ void uic_mqtt_dotdot_on_alarms_reset_alarm( + } + + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; ++ uint8_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18740,7 +18740,7 @@ static void uic_mqtt_dotdot_on_generated_alarms_reset_alarm( + } + + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; ++ uint8_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18805,7 +18805,7 @@ void uic_mqtt_dotdot_on_alarms_alarm( + } + + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; ++ uint8_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18869,7 +18869,7 @@ static void uic_mqtt_dotdot_on_generated_alarms_alarm( + } + + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; ++ uint8_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -19038,8 +19038,8 @@ void uic_mqtt_dotdot_on_alarms_get_alarm_response( + + zclStatus status = {}; + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; +- uint32_t time_stamp = {}; ++ uint8_t cluster_identifier = {}; ++ int32_t time_stamp = {}; + + + nlohmann::json jsn; +@@ -19112,8 +19112,8 @@ static void uic_mqtt_dotdot_on_generated_alarms_get_alarm_response( + + zclStatus status = {}; + uint8_t alarm_code = {}; +- uint16_t cluster_identifier = {}; +- uint32_t time_stamp = {}; ++ uint8_t cluster_identifier = {}; ++ int32_t time_stamp = {}; + + + nlohmann::json jsn; +@@ -19495,7 +19495,7 @@ static void uic_mqtt_dotdot_on_alarms_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_alarms_alarm_count_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -19821,7 +19821,7 @@ static void uic_mqtt_dotdot_on_time_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_time_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20030,7 +20030,7 @@ sl_status_t uic_mqtt_dotdot_time_time_zone_unretain( + + sl_status_t uic_mqtt_dotdot_time_dst_start_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20100,7 +20100,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_start_unretain( + + sl_status_t uic_mqtt_dotdot_time_dst_end_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20240,7 +20240,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_shift_unretain( + + sl_status_t uic_mqtt_dotdot_time_standard_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20310,7 +20310,7 @@ sl_status_t uic_mqtt_dotdot_time_standard_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_local_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20380,7 +20380,7 @@ sl_status_t uic_mqtt_dotdot_time_local_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_last_set_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20450,7 +20450,7 @@ sl_status_t uic_mqtt_dotdot_time_last_set_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_valid_until_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20885,7 +20885,7 @@ void uic_mqtt_dotdot_on_poll_control_check_in_response( + } + + bool start_fast_polling = {}; +- uint16_t fast_poll_timeout = {}; ++ int16_t fast_poll_timeout = {}; + + + nlohmann::json jsn; +@@ -20949,7 +20949,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_check_in_response( + } + + bool start_fast_polling = {}; +- uint16_t fast_poll_timeout = {}; ++ int16_t fast_poll_timeout = {}; + + + nlohmann::json jsn; +@@ -21116,7 +21116,7 @@ void uic_mqtt_dotdot_on_poll_control_set_long_poll_interval( + return; + } + +- uint32_t new_long_poll_interval = {}; ++ int32_t new_long_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21175,7 +21175,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_set_long_poll_interval( + return; + } + +- uint32_t new_long_poll_interval = {}; ++ int32_t new_long_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21235,7 +21235,7 @@ void uic_mqtt_dotdot_on_poll_control_set_short_poll_interval( + return; + } + +- uint16_t new_short_poll_interval = {}; ++ int16_t new_short_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21294,7 +21294,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_set_short_poll_interval( + return; + } + +- uint16_t new_short_poll_interval = {}; ++ int16_t new_short_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21470,7 +21470,7 @@ static void uic_mqtt_dotdot_on_poll_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21540,7 +21540,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21610,7 +21610,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21680,7 +21680,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21750,7 +21750,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21820,7 +21820,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21890,7 +21890,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22198,7 +22198,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22268,7 +22268,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_unretain( + + sl_status_t uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22407,7 +22407,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_status_unretain( + + sl_status_t uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -25590,7 +25590,7 @@ void uic_mqtt_dotdot_on_door_lock_unlock_with_timeout( + return; + } + +- uint16_t timeout_in_seconds = {}; ++ int16_t timeout_in_seconds = {}; + std::string pin_or_rfid_code; + + +@@ -25654,7 +25654,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_unlock_with_timeout( + return; + } + +- uint16_t timeout_in_seconds = {}; ++ int16_t timeout_in_seconds = {}; + std::string pin_or_rfid_code; + + +@@ -25838,7 +25838,7 @@ void uic_mqtt_dotdot_on_door_lock_get_log_record( + return; + } + +- uint16_t log_index = {}; ++ int16_t log_index = {}; + + + nlohmann::json jsn; +@@ -25897,7 +25897,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_log_record( + return; + } + +- uint16_t log_index = {}; ++ int16_t log_index = {}; + + + nlohmann::json jsn; +@@ -25957,12 +25957,12 @@ void uic_mqtt_dotdot_on_door_lock_get_log_record_response( + return; + } + +- uint16_t log_entryid = {}; +- uint32_t timestamp = {}; ++ int16_t log_entryid = {}; ++ int32_t timestamp = {}; + GetLogRecordResponseEventType event_type = {}; + DrlkOperEventSource source_operation_event = {}; +- uint8_t event_id_or_alarm_code = {}; +- uint16_t userid = {}; ++ int8_t event_id_or_alarm_code = {}; ++ int16_t userid = {}; + std::string pin; + + +@@ -26046,12 +26046,12 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_log_record_response( + return; + } + +- uint16_t log_entryid = {}; +- uint32_t timestamp = {}; ++ int16_t log_entryid = {}; ++ int32_t timestamp = {}; + GetLogRecordResponseEventType event_type = {}; + DrlkOperEventSource source_operation_event = {}; +- uint8_t event_id_or_alarm_code = {}; +- uint16_t userid = {}; ++ int8_t event_id_or_alarm_code = {}; ++ int16_t userid = {}; + std::string pin; + + +@@ -26136,7 +26136,7 @@ void uic_mqtt_dotdot_on_door_lock_set_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string pin; +@@ -26210,7 +26210,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string pin; +@@ -26404,7 +26404,7 @@ void uic_mqtt_dotdot_on_door_lock_get_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -26463,7 +26463,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -26523,7 +26523,7 @@ void uic_mqtt_dotdot_on_door_lock_get_pin_code_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string code; +@@ -26597,7 +26597,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_pin_code_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string code; +@@ -26672,7 +26672,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -26731,7 +26731,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_pin_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -27132,7 +27132,7 @@ void uic_mqtt_dotdot_on_door_lock_set_user_status( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + + +@@ -27196,7 +27196,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user_status( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + + +@@ -27380,7 +27380,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_status( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -27439,7 +27439,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_status( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -27499,7 +27499,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_status_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + + +@@ -27563,7 +27563,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_status_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + + +@@ -27628,13 +27628,13 @@ void uic_mqtt_dotdot_on_door_lock_set_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + uint8_t days_mask = {}; +- uint8_t start_hour = {}; +- uint8_t start_minute = {}; +- uint8_t end_hour = {}; +- uint8_t end_minute = {}; ++ int8_t start_hour = {}; ++ int8_t start_minute = {}; ++ int8_t end_hour = {}; ++ int8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -27717,13 +27717,13 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + uint8_t days_mask = {}; +- uint8_t start_hour = {}; +- uint8_t start_minute = {}; +- uint8_t end_hour = {}; +- uint8_t end_minute = {}; ++ int8_t start_hour = {}; ++ int8_t start_minute = {}; ++ int8_t end_hour = {}; ++ int8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -27926,8 +27926,8 @@ void uic_mqtt_dotdot_on_door_lock_get_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -27990,8 +27990,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -28055,14 +28055,14 @@ void uic_mqtt_dotdot_on_door_lock_get_weekday_schedule_response( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ int8_t scheduleid = {}; ++ int16_t userid = {}; + zclStatus status = {}; + uint8_t days_mask = {}; +- uint8_t start_hour = {}; +- uint8_t start_minute = {}; +- uint8_t end_hour = {}; +- uint8_t end_minute = {}; ++ int8_t start_hour = {}; ++ int8_t start_minute = {}; ++ int8_t end_hour = {}; ++ int8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -28149,14 +28149,14 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_weekday_schedule_response + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ int8_t scheduleid = {}; ++ int16_t userid = {}; + zclStatus status = {}; + uint8_t days_mask = {}; +- uint8_t start_hour = {}; +- uint8_t start_minute = {}; +- uint8_t end_hour = {}; +- uint8_t end_minute = {}; ++ int8_t start_hour = {}; ++ int8_t start_minute = {}; ++ int8_t end_hour = {}; ++ int8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -28244,8 +28244,8 @@ void uic_mqtt_dotdot_on_door_lock_clear_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -28308,8 +28308,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_weekday_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -28492,10 +28492,10 @@ void uic_mqtt_dotdot_on_door_lock_set_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28566,10 +28566,10 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28760,8 +28760,8 @@ void uic_mqtt_dotdot_on_door_lock_get_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -28824,8 +28824,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -28889,11 +28889,11 @@ void uic_mqtt_dotdot_on_door_lock_get_year_day_schedule_response( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ int8_t scheduleid = {}; ++ int16_t userid = {}; + zclStatus status = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28968,11 +28968,11 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_year_day_schedule_respons + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ int8_t scheduleid = {}; ++ int16_t userid = {}; + zclStatus status = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -29048,8 +29048,8 @@ void uic_mqtt_dotdot_on_door_lock_clear_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -29112,8 +29112,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_year_day_schedule( + return; + } + +- uint8_t scheduleid = {}; +- uint16_t userid = {}; ++ uint8_t * scheduleid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -29296,9 +29296,9 @@ void uic_mqtt_dotdot_on_door_lock_set_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ uint8_t * holiday_scheduleid = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29370,9 +29370,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ uint8_t * holiday_scheduleid = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29564,7 +29564,7 @@ void uic_mqtt_dotdot_on_door_lock_get_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; ++ uint8_t * holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29623,7 +29623,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; ++ uint8_t * holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29683,10 +29683,10 @@ void uic_mqtt_dotdot_on_door_lock_get_holiday_schedule_response( + return; + } + +- uint8_t holiday_scheduleid = {}; ++ int8_t holiday_scheduleid = {}; + zclStatus status = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29762,10 +29762,10 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_holiday_schedule_response + return; + } + +- uint8_t holiday_scheduleid = {}; ++ int8_t holiday_scheduleid = {}; + zclStatus status = {}; +- uint32_t local_start_time = {}; +- uint32_t local_end_time = {}; ++ int32_t local_start_time = {}; ++ int32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29842,7 +29842,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; ++ uint8_t * holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29901,7 +29901,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_holiday_schedule( + return; + } + +- uint8_t holiday_scheduleid = {}; ++ uint8_t * holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -30080,7 +30080,7 @@ void uic_mqtt_dotdot_on_door_lock_set_user_type( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkUserType user_type = {}; + + +@@ -30144,7 +30144,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user_type( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkUserType user_type = {}; + + +@@ -30328,7 +30328,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_type( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -30387,7 +30387,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_type( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -30447,7 +30447,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_type_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30511,7 +30511,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_type_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30576,7 +30576,7 @@ void uic_mqtt_dotdot_on_door_lock_set_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -30650,7 +30650,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -30844,7 +30844,7 @@ void uic_mqtt_dotdot_on_door_lock_get_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -30903,7 +30903,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -30963,7 +30963,7 @@ void uic_mqtt_dotdot_on_door_lock_get_rfid_code_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -31037,7 +31037,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_rfid_code_response( + return; + } + +- uint16_t userid = {}; ++ int16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -31112,7 +31112,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -31171,7 +31171,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_rfid_code( + return; + } + +- uint16_t userid = {}; ++ uint8_t * userid = {}; + + + nlohmann::json jsn; +@@ -31573,9 +31573,9 @@ void uic_mqtt_dotdot_on_door_lock_set_user( + } + + DataOperationTypeEnum operation_type = {}; +- uint16_t user_index = {}; ++ int16_t user_index = {}; + std::string user_name; +- uint32_t user_uniqueid = {}; ++ int32_t user_uniqueid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + CredentialRuleEnum credential_rule = {}; +@@ -31662,9 +31662,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user( + } + + DataOperationTypeEnum operation_type = {}; +- uint16_t user_index = {}; ++ int16_t user_index = {}; + std::string user_name; +- uint32_t user_uniqueid = {}; ++ int32_t user_uniqueid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + CredentialRuleEnum credential_rule = {}; +@@ -31751,7 +31751,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user( + return; + } + +- uint16_t user_index = {}; ++ int16_t user_index = {}; + + + nlohmann::json jsn; +@@ -31810,7 +31810,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user( + return; + } + +- uint16_t user_index = {}; ++ int16_t user_index = {}; + + + nlohmann::json jsn; +@@ -31973,7 +31973,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_user( + return; + } + +- uint16_t user_index = {}; ++ int16_t user_index = {}; + + + nlohmann::json jsn; +@@ -32032,7 +32032,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_user( + return; + } + +- uint16_t user_index = {}; ++ int16_t user_index = {}; + + + nlohmann::json jsn; +@@ -32094,9 +32094,9 @@ void uic_mqtt_dotdot_on_door_lock_operating_event_notification( + + DrlkOperEventSource operation_event_source = {}; + OperatingEventNotificationOperationEventCode operation_event_code = {}; +- uint16_t userid = {}; ++ int16_t userid = {}; + std::string pin; +- uint32_t local_time = {}; ++ int32_t local_time = {}; + std::string data; + + +@@ -32178,9 +32178,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_operating_event_notification( + + DrlkOperEventSource operation_event_source = {}; + OperatingEventNotificationOperationEventCode operation_event_code = {}; +- uint16_t userid = {}; ++ int16_t userid = {}; + std::string pin; +- uint32_t local_time = {}; ++ int32_t local_time = {}; + std::string data; + + +@@ -32263,11 +32263,11 @@ void uic_mqtt_dotdot_on_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventSource program_event_source = {}; + ProgrammingEventNotificationProgramEventCode program_event_code = {}; +- uint16_t userid = {}; ++ int16_t userid = {}; + std::string pin; + DrlkUserType user_type = {}; + DrlkUserStatus user_status = {}; +- uint32_t local_time = {}; ++ int32_t local_time = {}; + std::string data; + + +@@ -32357,11 +32357,11 @@ static void uic_mqtt_dotdot_on_generated_door_lock_programming_event_notificatio + + ProgrammingEventNotificationProgramEventSource program_event_source = {}; + ProgrammingEventNotificationProgramEventCode program_event_code = {}; +- uint16_t userid = {}; ++ int16_t userid = {}; + std::string pin; + DrlkUserType user_type = {}; + DrlkUserStatus user_status = {}; +- uint32_t local_time = {}; ++ int32_t local_time = {}; + std::string data; + + +@@ -32453,7 +32453,7 @@ void uic_mqtt_dotdot_on_door_lock_set_credential( + DataOperationTypeEnum operation_type = {}; + CredentialStruct credential = {}; + std::string credential_data; +- uint16_t user_index = {}; ++ int16_t user_index = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + +@@ -32537,7 +32537,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_credential( + DataOperationTypeEnum operation_type = {}; + CredentialStruct credential = {}; + std::string credential_data; +- uint16_t user_index = {}; ++ int16_t user_index = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + +@@ -33669,7 +33669,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_state_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33739,7 +33739,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33809,7 +33809,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_open_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33879,7 +33879,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_open_period_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33949,7 +33949,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34019,7 +34019,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34089,7 +34089,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34159,7 +34159,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34229,7 +34229,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34299,7 +34299,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34369,7 +34369,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_unre + + sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34439,7 +34439,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34509,7 +34509,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34579,7 +34579,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34718,7 +34718,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_credential_rules_support_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34924,7 +34924,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_language_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_led_settings_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34994,7 +34994,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_led_settings_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35064,7 +35064,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_sound_volume_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35694,7 +35694,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_local_programming_features_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35764,7 +35764,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -36047,7 +36047,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_security_level_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -37890,7 +37890,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_lift_value( + return; + } + +- uint16_t lift_value = {}; ++ int16_t lift_value = {}; + + + nlohmann::json jsn; +@@ -37949,7 +37949,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_lift_value( + return; + } + +- uint16_t lift_value = {}; ++ int16_t lift_value = {}; + + + nlohmann::json jsn; +@@ -38009,7 +38009,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_lift_percentage( + return; + } + +- uint8_t percentage_lift_value = {}; ++ int8_t percentage_lift_value = {}; + + + nlohmann::json jsn; +@@ -38068,7 +38068,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_lift_percentage( + return; + } + +- uint8_t percentage_lift_value = {}; ++ int8_t percentage_lift_value = {}; + + + nlohmann::json jsn; +@@ -38128,7 +38128,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_tilt_value( + return; + } + +- uint16_t tilt_value = {}; ++ int16_t tilt_value = {}; + + + nlohmann::json jsn; +@@ -38187,7 +38187,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_tilt_value( + return; + } + +- uint16_t tilt_value = {}; ++ int16_t tilt_value = {}; + + + nlohmann::json jsn; +@@ -38247,7 +38247,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_tilt_percentage( + return; + } + +- uint8_t percentage_tilt_value = {}; ++ int8_t percentage_tilt_value = {}; + + + nlohmann::json jsn; +@@ -38306,7 +38306,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_tilt_percentage( + return; + } + +- uint8_t percentage_tilt_value = {}; ++ int8_t percentage_tilt_value = {}; + + + nlohmann::json jsn; +@@ -38581,7 +38581,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_window_covering_type_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38651,7 +38651,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38721,7 +38721,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38791,7 +38791,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38861,7 +38861,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38931,7 +38931,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39070,7 +39070,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_config_or_status_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39140,7 +39140,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_unr + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39210,7 +39210,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_unr + + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39280,7 +39280,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39350,7 +39350,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39420,7 +39420,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39490,7 +39490,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39560,7 +39560,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39630,7 +39630,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39769,7 +39769,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_mode_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39835,7 +39835,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + const char *base_topic, +- const char* value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40113,7 +40113,7 @@ void uic_mqtt_dotdot_on_barrier_control_go_to_percent( + return; + } + +- uint8_t percent_open = {}; ++ int8_t percent_open = {}; + + + nlohmann::json jsn; +@@ -40172,7 +40172,7 @@ static void uic_mqtt_dotdot_on_generated_barrier_control_go_to_percent( + return; + } + +- uint8_t percent_open = {}; ++ int8_t percent_open = {}; + + + nlohmann::json jsn; +@@ -40668,7 +40668,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_capabilities_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_open_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40738,7 +40738,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_close_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40808,7 +40808,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40878,7 +40878,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40948,7 +40948,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_open_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41018,7 +41018,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_period_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_close_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41088,7 +41088,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_period_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_barrier_position_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41480,7 +41480,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_pressure_unretain + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41550,7 +41550,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41900,7 +41900,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_comp_pressure_unr + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41970,7 +41970,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_unret + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42040,7 +42040,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_unret + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42110,7 +42110,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_unreta + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42605,7 +42605,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_capacity_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42675,7 +42675,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42745,7 +42745,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hour + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42815,7 +42815,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -43862,12 +43862,12 @@ void uic_mqtt_dotdot_on_thermostat_get_relay_status_log_response( + return; + } + +- uint16_t time_of_day = {}; ++ int16_t time_of_day = {}; + uint8_t relay_status = {}; + int16_t local_temperature = {}; +- uint8_t humidity_percentage = {}; ++ int8_t humidity_percentage = {}; + int16_t set_point = {}; +- uint16_t unread_entries = {}; ++ int16_t unread_entries = {}; + + + nlohmann::json jsn; +@@ -43946,12 +43946,12 @@ static void uic_mqtt_dotdot_on_generated_thermostat_get_relay_status_log_respons + return; + } + +- uint16_t time_of_day = {}; ++ int16_t time_of_day = {}; + uint8_t relay_status = {}; + int16_t local_temperature = {}; +- uint8_t humidity_percentage = {}; ++ int8_t humidity_percentage = {}; + int16_t set_point = {}; +- uint16_t unread_entries = {}; ++ int16_t unread_entries = {}; + + + nlohmann::json jsn; +@@ -45057,7 +45057,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_abs_max_cool_setpoint_limit_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -45127,7 +45127,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46396,7 +46396,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_start_of_week_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46466,7 +46466,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46609,7 +46609,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46960,7 +46960,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_amount_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47030,7 +47030,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_unretain + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47100,7 +47100,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47170,7 +47170,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47240,7 +47240,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47310,7 +47310,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47380,7 +47380,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47450,7 +47450,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47593,7 +47593,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_ac_type_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_ac_capacity_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48692,7 +48692,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48762,7 +48762,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_unretain( + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48832,7 +48832,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_un + + sl_status_t uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -49048,7 +49048,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_lockout_un + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -49118,7 +49118,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -50425,9 +50425,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_hue( + return; + } + +- uint8_t hue = {}; ++ int8_t hue = {}; + CCDirection direction = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50504,9 +50504,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_hue( + return; + } + +- uint8_t hue = {}; ++ int8_t hue = {}; + CCDirection direction = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50585,7 +50585,7 @@ void uic_mqtt_dotdot_on_color_control_move_hue( + } + + CCMoveMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50659,7 +50659,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_hue( + } + + CCMoveMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50734,8 +50734,8 @@ void uic_mqtt_dotdot_on_color_control_step_hue( + } + + CCStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint8_t transition_time = {}; ++ int8_t step_size = {}; ++ int8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50813,8 +50813,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_hue( + } + + CCStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint8_t transition_time = {}; ++ int8_t step_size = {}; ++ int8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50892,8 +50892,8 @@ void uic_mqtt_dotdot_on_color_control_move_to_saturation( + return; + } + +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50966,8 +50966,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_saturation( + return; + } + +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51042,7 +51042,7 @@ void uic_mqtt_dotdot_on_color_control_move_saturation( + } + + CCMoveMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51116,7 +51116,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_saturation( + } + + CCMoveMode move_mode = {}; +- uint8_t rate = {}; ++ int8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51191,8 +51191,8 @@ void uic_mqtt_dotdot_on_color_control_step_saturation( + } + + CCStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint8_t transition_time = {}; ++ int8_t step_size = {}; ++ int8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51270,8 +51270,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_saturation( + } + + CCStepMode step_mode = {}; +- uint8_t step_size = {}; +- uint8_t transition_time = {}; ++ int8_t step_size = {}; ++ int8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51349,9 +51349,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_hue_and_saturation( + return; + } + +- uint8_t hue = {}; +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int8_t hue = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51428,9 +51428,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_hue_and_saturatio + return; + } + +- uint8_t hue = {}; +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int8_t hue = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51508,9 +51508,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_color( + return; + } + +- uint16_t colorx = {}; +- uint16_t colory = {}; +- uint16_t transition_time = {}; ++ int16_t colorx = {}; ++ int16_t colory = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51587,9 +51587,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_color( + return; + } + +- uint16_t colorx = {}; +- uint16_t colory = {}; +- uint16_t transition_time = {}; ++ int16_t colorx = {}; ++ int16_t colory = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51818,7 +51818,7 @@ void uic_mqtt_dotdot_on_color_control_step_color( + + int16_t stepx = {}; + int16_t stepy = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51897,7 +51897,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_color( + + int16_t stepx = {}; + int16_t stepy = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51975,8 +51975,8 @@ void uic_mqtt_dotdot_on_color_control_move_to_color_temperature( + return; + } + +- uint16_t color_temperature_mireds = {}; +- uint16_t transition_time = {}; ++ int16_t color_temperature_mireds = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52049,8 +52049,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_color_temperature + return; + } + +- uint16_t color_temperature_mireds = {}; +- uint16_t transition_time = {}; ++ int16_t color_temperature_mireds = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52124,9 +52124,9 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_to_hue( + return; + } + +- uint16_t enhanced_hue = {}; ++ int16_t enhanced_hue = {}; + CCDirection direction = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52203,9 +52203,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_to_hue( + return; + } + +- uint16_t enhanced_hue = {}; ++ int16_t enhanced_hue = {}; + CCDirection direction = {}; +- uint16_t transition_time = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52284,7 +52284,7 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_hue( + } + + CCMoveMode move_mode = {}; +- uint16_t rate = {}; ++ int16_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52358,7 +52358,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_hue( + } + + CCMoveMode move_mode = {}; +- uint16_t rate = {}; ++ int16_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52433,8 +52433,8 @@ void uic_mqtt_dotdot_on_color_control_enhanced_step_hue( + } + + CCStepMode step_mode = {}; +- uint16_t step_size = {}; +- uint16_t transition_time = {}; ++ int16_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52512,8 +52512,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_step_hue( + } + + CCStepMode step_mode = {}; +- uint16_t step_size = {}; +- uint16_t transition_time = {}; ++ int16_t step_size = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52591,9 +52591,9 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_to_hue_and_saturation( + return; + } + +- uint16_t enhanced_hue = {}; +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int16_t enhanced_hue = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52670,9 +52670,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_to_hue_and_ + return; + } + +- uint16_t enhanced_hue = {}; +- uint8_t saturation = {}; +- uint16_t transition_time = {}; ++ int16_t enhanced_hue = {}; ++ int8_t saturation = {}; ++ int16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52753,8 +52753,8 @@ void uic_mqtt_dotdot_on_color_control_color_loop_set( + uint8_t update_flags = {}; + ColorLoopSetAction action = {}; + CCColorLoopDirection direction = {}; +- uint16_t time = {}; +- uint16_t start_hue = {}; ++ int16_t time = {}; ++ int16_t start_hue = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52842,8 +52842,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_color_loop_set( + uint8_t update_flags = {}; + ColorLoopSetAction action = {}; + CCColorLoopDirection direction = {}; +- uint16_t time = {}; +- uint16_t start_hue = {}; ++ int16_t time = {}; ++ int16_t start_hue = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53059,9 +53059,9 @@ void uic_mqtt_dotdot_on_color_control_move_color_temperature( + } + + CCMoveMode move_mode = {}; +- uint16_t rate = {}; +- uint16_t color_temperature_minimum_mireds = {}; +- uint16_t color_temperature_maximum_mireds = {}; ++ int16_t rate = {}; ++ uint8_t * color_temperature_minimum_mireds = {}; ++ uint8_t * color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53143,9 +53143,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_color_temperature( + } + + CCMoveMode move_mode = {}; +- uint16_t rate = {}; +- uint16_t color_temperature_minimum_mireds = {}; +- uint16_t color_temperature_maximum_mireds = {}; ++ int16_t rate = {}; ++ uint8_t * color_temperature_minimum_mireds = {}; ++ uint8_t * color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53228,10 +53228,10 @@ void uic_mqtt_dotdot_on_color_control_step_color_temperature( + } + + CCStepMode step_mode = {}; +- uint16_t step_size = {}; +- uint16_t transition_time = {}; +- uint16_t color_temperature_minimum_mireds = {}; +- uint16_t color_temperature_maximum_mireds = {}; ++ int16_t step_size = {}; ++ int16_t transition_time = {}; ++ uint8_t * color_temperature_minimum_mireds = {}; ++ uint8_t * color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53317,10 +53317,10 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_color_temperature( + } + + CCStepMode step_mode = {}; +- uint16_t step_size = {}; +- uint16_t transition_time = {}; +- uint16_t color_temperature_minimum_mireds = {}; +- uint16_t color_temperature_maximum_mireds = {}; ++ int16_t step_size = {}; ++ int16_t transition_time = {}; ++ uint8_t * color_temperature_minimum_mireds = {}; ++ uint8_t * color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53612,7 +53612,7 @@ static void uic_mqtt_dotdot_on_color_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_color_control_current_hue_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53682,7 +53682,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_hue_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_current_saturation_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53752,7 +53752,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_saturation_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_remaining_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53822,7 +53822,7 @@ sl_status_t uic_mqtt_dotdot_color_control_remaining_time_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_currentx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53892,7 +53892,7 @@ sl_status_t uic_mqtt_dotdot_color_control_currentx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_currenty_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54101,7 +54101,7 @@ sl_status_t uic_mqtt_dotdot_color_control_compensation_text_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54313,7 +54313,7 @@ sl_status_t uic_mqtt_dotdot_color_control_options_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54383,7 +54383,7 @@ sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54453,7 +54453,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54523,7 +54523,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54593,7 +54593,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54663,7 +54663,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54733,7 +54733,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54803,7 +54803,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54873,7 +54873,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54943,7 +54943,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55013,7 +55013,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55083,7 +55083,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55153,7 +55153,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55223,7 +55223,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55293,7 +55293,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55363,7 +55363,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55433,7 +55433,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6x_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55503,7 +55503,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6y_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55573,7 +55573,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55643,7 +55643,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_white_pointx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55713,7 +55713,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_white_pointy_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55783,7 +55783,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointy_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55853,7 +55853,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55923,7 +55923,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointry_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55993,7 +55993,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56063,7 +56063,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56133,7 +56133,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56203,7 +56203,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56273,7 +56273,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointby_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56343,7 +56343,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointby_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56413,7 +56413,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56556,7 +56556,7 @@ sl_status_t uic_mqtt_dotdot_color_control_enhanced_color_mode_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56626,7 +56626,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56696,7 +56696,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56766,7 +56766,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56836,7 +56836,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_unretain + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56975,7 +56975,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_capabilities_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57045,7 +57045,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_unretai + + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57115,7 +57115,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_unretai + + sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57185,7 +57185,7 @@ sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_ + + sl_status_t uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57627,7 +57627,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57697,7 +57697,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57836,7 +57836,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_status_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57906,7 +57906,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57976,7 +57976,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58046,7 +58046,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58116,7 +58116,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58186,7 +58186,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_unret + + sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58256,7 +58256,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_unre + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58458,7 +58458,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_manufacturer_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58528,7 +58528,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58667,7 +58667,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_alarm_mode_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58935,7 +58935,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59005,7 +59005,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59075,7 +59075,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59145,7 +59145,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59628,7 +59628,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_light_sensor_type_unretain + + sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60104,7 +60104,7 @@ sl_status_t uic_mqtt_dotdot_temperature_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60590,7 +60590,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60870,7 +60870,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_scaled_value_unretain( + + sl_status_t uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61206,7 +61206,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61276,7 +61276,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61346,7 +61346,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61416,7 +61416,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61682,7 +61682,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61752,7 +61752,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61822,7 +61822,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61892,7 +61892,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62385,7 +62385,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_occupancy_sensor_type_bitmap_unret + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62455,7 +62455,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_u + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62525,7 +62525,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_u + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62595,7 +62595,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_thresho + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62665,7 +62665,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62735,7 +62735,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62805,7 +62805,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62875,7 +62875,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unocc + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62945,7 +62945,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63211,7 +63211,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63281,7 +63281,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63351,7 +63351,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63421,7 +63421,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63687,7 +63687,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63757,7 +63757,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63827,7 +63827,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63897,7 +63897,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64163,7 +64163,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_force_read_at + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64233,7 +64233,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_u + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64303,7 +64303,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_val + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64373,7 +64373,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_val + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64639,7 +64639,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64709,7 +64709,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64779,7 +64779,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64849,7 +64849,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -66609,7 +66609,7 @@ void uic_mqtt_dotdot_on_ias_zone_zone_enroll_response( + } + + ZoneEnrollResponseEnrollResponseCode enroll_response_code = {}; +- uint8_t zoneid = {}; ++ int8_t zoneid = {}; + + + nlohmann::json jsn; +@@ -66673,7 +66673,7 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_enroll_response( + } + + ZoneEnrollResponseEnrollResponseCode enroll_response_code = {}; +- uint8_t zoneid = {}; ++ int8_t zoneid = {}; + + + nlohmann::json jsn; +@@ -66739,8 +66739,8 @@ void uic_mqtt_dotdot_on_ias_zone_zone_status_change_notification( + + uint16_t zone_status = {}; + uint8_t extended_status = {}; +- uint8_t zoneid = {}; +- uint16_t delay = {}; ++ int8_t zoneid = {}; ++ int16_t delay = {}; + + + nlohmann::json jsn; +@@ -66813,8 +66813,8 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_status_change_notificatio + + uint16_t zone_status = {}; + uint8_t extended_status = {}; +- uint8_t zoneid = {}; +- uint16_t delay = {}; ++ int8_t zoneid = {}; ++ int16_t delay = {}; + + + nlohmann::json jsn; +@@ -66990,7 +66990,7 @@ void uic_mqtt_dotdot_on_ias_zone_zone_enroll_request( + } + + IasZoneType zone_type = {}; +- uint16_t manufacturer_code = {}; ++ int16_t manufacturer_code = {}; + + + nlohmann::json jsn; +@@ -67054,7 +67054,7 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_enroll_request( + } + + IasZoneType zone_type = {}; +- uint16_t manufacturer_code = {}; ++ int16_t manufacturer_code = {}; + + + nlohmann::json jsn; +@@ -67118,8 +67118,8 @@ void uic_mqtt_dotdot_on_ias_zone_initiate_test_mode( + return; + } + +- uint8_t test_mode_duration = {}; +- uint8_t current_zone_sensitivity_level = {}; ++ int8_t test_mode_duration = {}; ++ int8_t current_zone_sensitivity_level = {}; + + + nlohmann::json jsn; +@@ -67182,8 +67182,8 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_initiate_test_mode( + return; + } + +- uint8_t test_mode_duration = {}; +- uint8_t current_zone_sensitivity_level = {}; ++ int8_t test_mode_duration = {}; ++ int8_t current_zone_sensitivity_level = {}; + + + nlohmann::json jsn; +@@ -67648,7 +67648,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_iascie_address_unretain( + + sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -67718,7 +67718,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_unretain( + + sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -67788,7 +67788,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported + + sl_status_t uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68055,8 +68055,8 @@ void uic_mqtt_dotdot_on_iaswd_start_warning( + } + + uint8_t siren_configuration = {}; +- uint16_t warning_duration = {}; +- uint8_t strobe_duty_cycle = {}; ++ int16_t warning_duration = {}; ++ int8_t strobe_duty_cycle = {}; + IaswdLevel strobe_level = {}; + + +@@ -68129,8 +68129,8 @@ static void uic_mqtt_dotdot_on_generated_iaswd_start_warning( + } + + uint8_t siren_configuration = {}; +- uint16_t warning_duration = {}; +- uint8_t strobe_duty_cycle = {}; ++ int16_t warning_duration = {}; ++ int8_t strobe_duty_cycle = {}; + IaswdLevel strobe_level = {}; + + +@@ -68426,7 +68426,7 @@ static void uic_mqtt_dotdot_on_iaswd_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_iaswd_max_duration_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68752,7 +68752,7 @@ static void uic_mqtt_dotdot_on_metering_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68822,7 +68822,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_summation_received_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68892,7 +68892,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_received_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69102,7 +69102,7 @@ sl_status_t uic_mqtt_dotdot_metering_power_factor_unretain( + + sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69172,7 +69172,7 @@ sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69242,7 +69242,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + const char *base_topic, +- uint32_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69312,7 +69312,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_default_update_period_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69455,7 +69455,7 @@ sl_status_t uic_mqtt_dotdot_metering_supply_status_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69525,7 +69525,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_unre + + sl_status_t uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69808,7 +69808,7 @@ sl_status_t uic_mqtt_dotdot_metering_unitof_measure_unretain( + + sl_status_t uic_mqtt_dotdot_metering_multiplier_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69878,7 +69878,7 @@ sl_status_t uic_mqtt_dotdot_metering_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_metering_divisor_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -70807,10 +70807,10 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_profile_info_response( + return; + } + +- uint8_t profile_count = {}; ++ int8_t profile_count = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- uint8_t max_number_of_intervals = {}; +- std::vector list_of_attributes; ++ int8_t max_number_of_intervals = {}; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -70882,10 +70882,10 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_profile_info + return; + } + +- uint8_t profile_count = {}; ++ int8_t profile_count = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- uint8_t max_number_of_intervals = {}; +- std::vector list_of_attributes; ++ int8_t max_number_of_intervals = {}; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -71061,12 +71061,12 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_measurement_profile_response( + return; + } + +- uint32_t start_time = {}; ++ uint8_t start_time = {}; + GetMeasurementProfileResponseStatus status = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- uint8_t number_of_intervals_delivered = {}; +- uint16_t attribute_id = {}; +- std::vector intervals; ++ int8_t number_of_intervals_delivered = {}; ++ uint8_t attribute_id = {}; ++ std::vector intervals; + + + nlohmann::json jsn; +@@ -71146,12 +71146,12 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_measurement_ + return; + } + +- uint32_t start_time = {}; ++ uint8_t start_time = {}; + GetMeasurementProfileResponseStatus status = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- uint8_t number_of_intervals_delivered = {}; +- uint16_t attribute_id = {}; +- std::vector intervals; ++ int8_t number_of_intervals_delivered = {}; ++ uint8_t attribute_id = {}; ++ std::vector intervals; + + + nlohmann::json jsn; +@@ -71232,9 +71232,9 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_measurement_profile( + return; + } + +- uint16_t attributeid = {}; +- uint32_t start_time = {}; +- uint8_t number_of_intervals = {}; ++ uint8_t attributeid = {}; ++ uint8_t start_time = {}; ++ int8_t number_of_intervals = {}; + + + nlohmann::json jsn; +@@ -71301,9 +71301,9 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_measurement_ + return; + } + +- uint16_t attributeid = {}; +- uint32_t start_time = {}; +- uint8_t number_of_intervals = {}; ++ uint8_t attributeid = {}; ++ uint8_t start_time = {}; ++ int8_t number_of_intervals = {}; + + + nlohmann::json jsn; +@@ -72426,7 +72426,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72496,7 +72496,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72566,7 +72566,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72636,7 +72636,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72706,7 +72706,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72776,7 +72776,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72846,7 +72846,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72916,7 +72916,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72986,7 +72986,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -73056,7 +73056,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -73266,7 +73266,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_total_reactive_power_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74176,7 +74176,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_measured_phase11th_harmonic_c + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74246,7 +74246,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_unret + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74316,7 +74316,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74386,7 +74386,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74596,7 +74596,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_phase_harmonic_current_multip + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74806,7 +74806,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74876,7 +74876,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74946,7 +74946,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75016,7 +75016,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75086,7 +75086,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75156,7 +75156,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75506,7 +75506,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75646,7 +75646,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75716,7 +75716,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75786,7 +75786,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75856,7 +75856,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75926,7 +75926,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75996,7 +75996,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76066,7 +76066,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_unreta + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76136,7 +76136,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_unre + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76206,7 +76206,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76276,7 +76276,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76346,7 +76346,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76416,7 +76416,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76486,7 +76486,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77534,7 +77534,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77744,7 +77744,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phb_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77814,7 +77814,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77884,7 +77884,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77954,7 +77954,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78024,7 +78024,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78094,7 +78094,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78444,7 +78444,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78584,7 +78584,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78654,7 +78654,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78724,7 +78724,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78794,7 +78794,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78864,7 +78864,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78934,7 +78934,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79004,7 +79004,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_un + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79074,7 +79074,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_ + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79284,7 +79284,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phc_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79354,7 +79354,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79424,7 +79424,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79494,7 +79494,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79564,7 +79564,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79634,7 +79634,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79984,7 +79984,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80124,7 +80124,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80194,7 +80194,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80264,7 +80264,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80334,7 +80334,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80404,7 +80404,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80474,7 +80474,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80544,7 +80544,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_un + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80898,7 +80898,7 @@ static void uic_mqtt_dotdot_on_diagnostics_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80968,7 +80968,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81038,7 +81038,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81108,7 +81108,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81178,7 +81178,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81248,7 +81248,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81318,7 +81318,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81388,7 +81388,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81458,7 +81458,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81528,7 +81528,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81598,7 +81598,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81668,7 +81668,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81738,7 +81738,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81808,7 +81808,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81878,7 +81878,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81948,7 +81948,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82018,7 +82018,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82088,7 +82088,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82158,7 +82158,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82228,7 +82228,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82298,7 +82298,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82368,7 +82368,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82438,7 +82438,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82508,7 +82508,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82578,7 +82578,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82648,7 +82648,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82718,7 +82718,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_unretain + + sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82788,7 +82788,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82858,7 +82858,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82928,7 +82928,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + const char *base_topic, +- uint16_t value, ++ int16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82998,7 +82998,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_u + + sl_status_t uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + const char *base_topic, +- uint8_t value, ++ int8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -83262,17 +83262,17 @@ void uic_mqtt_dotdot_on_protocol_controller_rf_telemetry_tx_report( + std::string sourceunid; + std::string destinationunid; + bool transmission_successful = {}; +- uint16_t transmission_time_ms = {}; ++ int16_t transmission_time_ms = {}; + int8_t tx_powerd_bm = {}; +- uint8_t tx_channel = {}; +- uint8_t routing_attempts = {}; ++ int8_t tx_channel = {}; ++ int8_t routing_attempts = {}; + bool route_changed = {}; + TxReportTransmissionSpeed transmission_speed = {}; + int8_t measured_noise_floord_bm = {}; + std::vector last_route_repeaters; + std::vector incoming_rssi_repeaters; + int8_t ackrssi = {}; +- uint8_t ack_channel = {}; ++ int8_t ack_channel = {}; + std::string last_route_failed_link_functionalunid; + std::string last_route_failed_link_non_functionalunid; + int8_t destination_ack_tx_powerd_bm = {}; +@@ -83419,17 +83419,17 @@ static void uic_mqtt_dotdot_on_generated_protocol_controller_rf_telemetry_tx_rep + std::string sourceunid; + std::string destinationunid; + bool transmission_successful = {}; +- uint16_t transmission_time_ms = {}; ++ int16_t transmission_time_ms = {}; + int8_t tx_powerd_bm = {}; +- uint8_t tx_channel = {}; +- uint8_t routing_attempts = {}; ++ int8_t tx_channel = {}; ++ int8_t routing_attempts = {}; + bool route_changed = {}; + TxReportTransmissionSpeed transmission_speed = {}; + int8_t measured_noise_floord_bm = {}; + std::vector last_route_repeaters; + std::vector incoming_rssi_repeaters; + int8_t ackrssi = {}; +- uint8_t ack_channel = {}; ++ int8_t ack_channel = {}; + std::string last_route_failed_link_functionalunid; + std::string last_route_failed_link_non_functionalunid; + int8_t destination_ack_tx_powerd_bm = {}; +@@ -84854,7 +84854,7 @@ static void uic_mqtt_dotdot_on_state_force_read_attributes( + sl_status_t uic_mqtt_dotdot_state_endpoint_id_list_publish( + const char *base_topic, + size_t value_count, +- const uint8_t* value, ++ const int8_t* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -85071,7 +85071,7 @@ sl_status_t uic_mqtt_dotdot_state_security_unretain( + + sl_status_t uic_mqtt_dotdot_state_maximum_command_delay_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -85489,7 +85489,7 @@ void uic_mqtt_dotdot_on_binding_bind( + + std::string cluster_name; + std::string destination_unid; +- uint8_t destination_ep = {}; ++ int8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85558,7 +85558,7 @@ static void uic_mqtt_dotdot_on_generated_binding_bind( + + std::string cluster_name; + std::string destination_unid; +- uint8_t destination_ep = {}; ++ int8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85628,7 +85628,7 @@ void uic_mqtt_dotdot_on_binding_unbind( + + std::string cluster_name; + std::string destination_unid; +- uint8_t destination_ep = {}; ++ int8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85697,7 +85697,7 @@ static void uic_mqtt_dotdot_on_generated_binding_unbind( + + std::string cluster_name; + std::string destination_unid; +- uint8_t destination_ep = {}; ++ int8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -86605,7 +86605,7 @@ static void uic_mqtt_dotdot_on_system_metrics_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -87972,7 +87972,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_fqdn_unretain( + + sl_status_t uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -88462,7 +88462,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_battery_percentage_unretain( + + sl_status_t uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89224,7 +89224,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_application_mqtt_topics_unret + + sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89294,7 +89294,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_process_id_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89639,7 +89639,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_logging_level_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89709,7 +89709,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_int + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89779,7 +89779,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89849,7 +89849,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_unreta + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + const char *base_topic, +- uint64_t value, ++ int64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -90129,7 +90129,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_max_delivery_time_second + + sl_status_t uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- uint32_t value, ++ int32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -91106,7 +91106,7 @@ void uic_mqtt_dotdot_on_configuration_parameters_discover_parameter( + return; + } + +- uint16_t parameter_id = {}; ++ int16_t parameter_id = {}; + + + nlohmann::json jsn; +@@ -91165,7 +91165,7 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_discover_param + return; + } + +- uint16_t parameter_id = {}; ++ int16_t parameter_id = {}; + + + nlohmann::json jsn; +@@ -91328,7 +91328,7 @@ void uic_mqtt_dotdot_on_configuration_parameters_set_parameter( + return; + } + +- uint16_t parameter_id = {}; ++ int16_t parameter_id = {}; + int64_t value = {}; + + +@@ -91392,7 +91392,7 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_set_parameter( + return; + } + +- uint16_t parameter_id = {}; ++ int16_t parameter_id = {}; + int64_t value = {}; + + +@@ -91457,8 +91457,8 @@ void uic_mqtt_dotdot_on_configuration_parameters_discover_parameter_range( + return; + } + +- uint16_t first_parameter_id = {}; +- uint16_t last_parameter_id = {}; ++ int16_t first_parameter_id = {}; ++ int16_t last_parameter_id = {}; + + + nlohmann::json jsn; +@@ -91521,8 +91521,8 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_discover_param + return; + } + +- uint16_t first_parameter_id = {}; +- uint16_t last_parameter_id = {}; ++ int16_t first_parameter_id = {}; ++ int16_t last_parameter_id = {}; + + + nlohmann::json jsn; +@@ -91830,467 +91830,757 @@ sl_status_t uic_mqtt_dotdot_configuration_parameters_init() + } + + // Callbacks pointers +-static std::set uic_mqtt_dotdot_protocol_controller_network_management_write_callback; +-static std::set uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback; +-static std::set uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback; +-static std::set uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback; ++static std::set uic_mqtt_dotdot_user_credential_add_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_add_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_modify_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_modify_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_add_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_add_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_modify_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_modify_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_credential_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_all_users_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_all_credentials_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback; ++static std::set uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback; ++static std::set uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback; ++static std::set uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback; ++static std::set uic_mqtt_dotdot_user_credential_credential_learn_stop_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback; ++static std::set uic_mqtt_dotdot_user_credential_credential_association_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_credential_association_callback; ++static std::set uic_mqtt_dotdot_user_credential_get_user_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_get_credential_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback; ++static std::set uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback; ++static std::set uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback; ++static std::set uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback; ++static std::set uic_mqtt_dotdot_user_credential_write_attributes_callback; ++static std::set uic_mqtt_dotdot_user_credential_force_read_attributes_callback; + + // Callbacks setters +-void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_set(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++void uic_mqtt_dotdot_user_credential_add_user_callback_set(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_protocol_controller_network_management_write_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_add_user_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_unset(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++void uic_mqtt_dotdot_user_credential_add_user_callback_unset(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback) + { +- uic_mqtt_dotdot_protocol_controller_network_management_write_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_add_user_callback.erase(callback); + } +-void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_clear() ++void uic_mqtt_dotdot_user_credential_add_user_callback_clear() + { +- uic_mqtt_dotdot_protocol_controller_network_management_write_callback.clear(); ++ uic_mqtt_dotdot_user_credential_add_user_callback.clear(); + } +-std::set& get_uic_mqtt_dotdot_protocol_controller_network_management_write_callback() ++std::set& get_uic_mqtt_dotdot_user_credential_add_user_callback() + { +- return uic_mqtt_dotdot_protocol_controller_network_management_write_callback; ++ return uic_mqtt_dotdot_user_credential_add_user_callback; + } + +-void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_set(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_set(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_generated_add_user_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_unset(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_unset(const uic_mqtt_dotdot_user_credential_add_user_callback_t callback) + { +- uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_generated_add_user_callback.erase(callback); + } +-void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_clear() ++void uic_mqtt_dotdot_user_credential_generated_add_user_callback_clear() + { +- uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.clear(); ++ uic_mqtt_dotdot_user_credential_generated_add_user_callback.clear(); + } +- +-void uic_mqtt_dotdot_set_protocol_controller_network_management_write_attributes_callback( +- const uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t callback) ++void uic_mqtt_dotdot_user_credential_modify_user_callback_set(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_modify_user_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_unset_protocol_controller_network_management_write_attributes_callback( +- const uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t callback) ++void uic_mqtt_dotdot_user_credential_modify_user_callback_unset(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback) + { +- uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_modify_user_callback.erase(callback); + } +-void uic_mqtt_dotdot_clear_protocol_controller_network_management_write_attributes_callbacks() ++void uic_mqtt_dotdot_user_credential_modify_user_callback_clear() + { +- uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.clear(); ++ uic_mqtt_dotdot_user_credential_modify_user_callback.clear(); + } +-std::set& get_uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback() ++std::set& get_uic_mqtt_dotdot_user_credential_modify_user_callback() + { +- return uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback; ++ return uic_mqtt_dotdot_user_credential_modify_user_callback; + } + +-void uic_mqtt_dotdot_set_protocol_controller_network_management_force_read_attributes_callback( +- const uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t callback) ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_set(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_generated_modify_user_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_unset_protocol_controller_network_management_force_read_attributes_callback( +- const uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t callback) ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_unset(const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback) + { +- uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_generated_modify_user_callback.erase(callback); + } +-void uic_mqtt_dotdot_clear_protocol_controller_network_management_force_read_attributes_callbacks() ++void uic_mqtt_dotdot_user_credential_generated_modify_user_callback_clear() + { +- uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.clear(); ++ uic_mqtt_dotdot_user_credential_generated_modify_user_callback.clear(); + } +- +- +-// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/Commands/Write +-void uic_mqtt_dotdot_on_protocol_controller_network_management_write( +- const char *topic, +- const char *message, +- const size_t message_length) ++void uic_mqtt_dotdot_user_credential_delete_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback) + { +- if (message_length == 0 || (uic_mqtt_dotdot_protocol_controller_network_management_write_callback.empty())) { +- return; +- } +- +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID from topic %s. Ignoring", +- topic); +- return; ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_user_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_delete_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_user_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_user_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_user_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_user_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_user_callback; ++} + +- +- +- nlohmann::json jsn; +- try { +- jsn = nlohmann::json::parse(std::string(message)); +- +- +- } catch (const nlohmann::json::parse_error& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "Write"); +- return; +- } catch (const nlohmann::json::exception& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", e.what()); +- return; +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", ""); +- return; ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_user_callback.insert(callback); + } +- +- +- +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_callback){ +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL +- ); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_user_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_user_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_user_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_add_credential_callback_set(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_add_credential_callback.insert(callback); + } +- ++} ++void uic_mqtt_dotdot_user_credential_add_credential_callback_unset(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_add_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_add_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_add_credential_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_add_credential_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_add_credential_callback; + } + +-// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/GeneratedCommands/Write +-static void uic_mqtt_dotdot_on_generated_protocol_controller_network_management_write( +- const char *topic, +- const char *message, +- const size_t message_length) ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_set(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback) + { +- if (message_length == 0 || (uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.empty())) { +- return; ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_add_credential_callback.insert(callback); + } +- +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID from topic %s. Ignoring", +- topic); +- return; ++} ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_unset(const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_add_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_add_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_add_credential_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_set(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_modify_credential_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_unset(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_modify_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_modify_credential_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_modify_credential_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_modify_credential_callback; ++} + +- +- +- nlohmann::json jsn; +- try { +- jsn = nlohmann::json::parse(std::string(message)); +- +- +- } catch (const nlohmann::json::parse_error& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "Write"); +- return; +- } catch (const nlohmann::json::exception& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", e.what()); +- return; +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", ""); +- return; ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_set(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_modify_credential_callback.insert(callback); + } +- +- +- +- +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback){ +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL +- ); ++} ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_unset(const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_modify_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_modify_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_modify_credential_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_set(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_credential_callback.insert(callback); + } + } ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_unset(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_credential_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_credential_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_credential_callback; ++} + +- +-// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/Commands/WriteAttributes +-void uic_mqtt_dotdot_on_protocol_controller_network_management_WriteAttributes( +- const char *topic, +- const char *message, +- const size_t message_length) ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_set(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback) + { +- if (uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.empty()) { +- return; ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_credential_callback.insert(callback); + } +- +- if (message_length == 0) { +- return; ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_unset(const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_credential_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_credential_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_credential_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_all_users_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_all_users_callback; ++} + +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID from topic %s. Ignoring", +- topic); +- return; ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback.insert(callback); + } +- +- uic_mqtt_dotdot_protocol_controller_network_management_state_t new_state = {}; +- uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t new_updated_state = {}; +- +- +- nlohmann::json jsn; +- try { +- jsn = nlohmann::json::parse(std::string(message)); +- +- uic_mqtt_dotdot_parse_protocol_controller_network_management_write_attributes( +- jsn, +- new_state, +- new_updated_state +- ); +- } catch (const nlohmann::json::parse_error& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "WriteAttributes"); +- return; +- } catch (const nlohmann::json::exception& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "WriteAttributes", e.what()); +- return; +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "WriteAttributes", ""); +- return; ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_all_credentials_callback; ++} + +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback){ +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- new_state, +- new_updated_state +- ); ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback.insert(callback); + } +- + } +- +-static void uic_mqtt_dotdot_on_protocol_controller_network_management_force_read_attributes( +- const char *topic, +- const char *message, +- const size_t message_length) ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback) + { +- uint8_t endpoint = 0; +- std::string unid; +- +- if ((message_length == 0) || (uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.empty())) { +- return; ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback; ++} + +- if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID / Endpoint ID from topic %s. Ignoring", +- topic); +- return; ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback.insert(callback); + } +- +- try { +- uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t force_update = {0}; +- bool trigger_handler = false; +- +- nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- std::vector attributes = jsn["value"].get>(); +- +- // Assume all attributes to be read on empty array received +- if (attributes.size() == 0) { +- force_update.network_management_state = true; +- trigger_handler = true; +- } else { +- std::unordered_map supported_attrs = { +- {"NetworkManagementState", &force_update.network_management_state }, +- }; +- +- for (auto& attribute : attributes) { +- auto found_attr = supported_attrs.find(attribute); +- if (found_attr != supported_attrs.end()) { +- *(found_attr->second) = true; +- trigger_handler = true; +- } +- } +- } +- +- if (trigger_handler == true) { +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback) { +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- force_update +- ); +- } +- } +- } catch (...) { +- sl_log_debug(LOG_TAG, "ProtocolController-NetworkManagement/Commands/ForceReadAttributes: Unable to parse JSON payload"); +- return; ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback.insert(callback); + } + } +- +-sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_network_management_state_publish( +- const char *base_topic, +- NetworkManagementState value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback) + { +- nlohmann::json jsn; +- +- // This is a single value +- +- nlohmann::json json_object = nlohmann::json::object(); +- json_object["State"] = value.State; +- json_object["SupportedStateList"] = value.SupportedStateList; +- json_object["StateParameters"] = value.StateParameters; +- json_object["RequestedStateParameters"] = value.RequestedStateParameters; +- jsn["value"]= json_object; +- ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback; ++} + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); +- } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController/NetworkManagement/Attributes/NetworkManagementState", e.what()); +- return SL_STATUS_OK; ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback; ++} + +- +- std::string topic = std::string(base_topic) + "/ProtocolController/NetworkManagement/Attributes/NetworkManagementState"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback.insert(callback); + } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_unset(const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback.insert(callback); + } +- return SL_STATUS_OK; + } +- +-sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_network_management_state_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/ProtocolController/NetworkManagement/Attributes/NetworkManagementState"; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback; ++} + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback.insert(callback); + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback.insert(callback); + } +- return SL_STATUS_OK; + } +-// clang-format off +- +- +-sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_init() ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback) + { +- std::string base_topic = "ucl/by-unid/+/"; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback; ++} + +- std::string subscription_topic; +- if(!uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.empty()) { +- subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_WriteAttributes); ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_credential_learn_stop_callback; ++} + +- if(!uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.empty()) { +- subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/ForceReadAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_force_read_attributes); ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_set(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback.insert(callback); + } +- if (!uic_mqtt_dotdot_protocol_controller_network_management_write_callback.empty()) { +- subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/Write"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_write); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_unset(const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_credential_association_callback_set(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_credential_association_callback.insert(callback); + } +- if (!uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.empty()) { +- subscription_topic = base_topic + "ProtocolController/NetworkManagement/GeneratedCommands/Write"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_protocol_controller_network_management_write); ++} ++void uic_mqtt_dotdot_user_credential_credential_association_callback_unset(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_credential_association_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_credential_association_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_credential_association_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_credential_association_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_credential_association_callback; ++} ++ ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_set(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_credential_association_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_unset(const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_association_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_credential_association_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_credential_association_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_get_user_checksum_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_get_user_checksum_callback; ++} + +- // Init the attributes for that cluster +- uic_mqtt_dotdot_protocol_controller_network_management_attributes_init(); ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_get_credential_checksum_callback; ++} + ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback; ++} + +- return SL_STATUS_OK; ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_unset(const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback; + } + +-// Callbacks pointers +-static std::set uic_mqtt_dotdot_descriptor_write_attributes_callback; +-static std::set uic_mqtt_dotdot_descriptor_force_read_attributes_callback; ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback.clear(); ++} ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback() ++{ ++ return uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback; ++} + +-// Callbacks setters ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback.insert(callback); ++ } ++} ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_unset(const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback.erase(callback); ++} ++void uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback_clear() ++{ ++ uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback.clear(); ++} + +-void uic_mqtt_dotdot_set_descriptor_write_attributes_callback( +- const uic_mqtt_dotdot_descriptor_write_attributes_callback_t callback) ++void uic_mqtt_dotdot_set_user_credential_write_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_write_attributes_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_descriptor_write_attributes_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_write_attributes_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_unset_descriptor_write_attributes_callback( +- const uic_mqtt_dotdot_descriptor_write_attributes_callback_t callback) ++void uic_mqtt_dotdot_unset_user_credential_write_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_write_attributes_callback_t callback) + { +- uic_mqtt_dotdot_descriptor_write_attributes_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_write_attributes_callback.erase(callback); + } +-void uic_mqtt_dotdot_clear_descriptor_write_attributes_callbacks() ++void uic_mqtt_dotdot_clear_user_credential_write_attributes_callbacks() + { +- uic_mqtt_dotdot_descriptor_write_attributes_callback.clear(); ++ uic_mqtt_dotdot_user_credential_write_attributes_callback.clear(); + } +-std::set& get_uic_mqtt_dotdot_descriptor_write_attributes_callback() ++std::set& get_uic_mqtt_dotdot_user_credential_write_attributes_callback() + { +- return uic_mqtt_dotdot_descriptor_write_attributes_callback; ++ return uic_mqtt_dotdot_user_credential_write_attributes_callback; + } + +-void uic_mqtt_dotdot_set_descriptor_force_read_attributes_callback( +- const uic_mqtt_dotdot_descriptor_force_read_attributes_callback_t callback) ++void uic_mqtt_dotdot_set_user_credential_force_read_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t callback) + { + if (callback != nullptr) { +- uic_mqtt_dotdot_descriptor_force_read_attributes_callback.insert(callback); ++ uic_mqtt_dotdot_user_credential_force_read_attributes_callback.insert(callback); + } + } +-void uic_mqtt_dotdot_unset_descriptor_force_read_attributes_callback( +- const uic_mqtt_dotdot_descriptor_force_read_attributes_callback_t callback) ++void uic_mqtt_dotdot_unset_user_credential_force_read_attributes_callback( ++ const uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t callback) + { +- uic_mqtt_dotdot_descriptor_force_read_attributes_callback.erase(callback); ++ uic_mqtt_dotdot_user_credential_force_read_attributes_callback.erase(callback); + } +-void uic_mqtt_dotdot_clear_descriptor_force_read_attributes_callbacks() ++void uic_mqtt_dotdot_clear_user_credential_force_read_attributes_callbacks() + { +- uic_mqtt_dotdot_descriptor_force_read_attributes_callback.clear(); ++ uic_mqtt_dotdot_user_credential_force_read_attributes_callback.clear(); + } + + +-// Callback function for incoming publications on ucl/by-unid/+/+/Descriptor/Commands/WriteAttributes +-void uic_mqtt_dotdot_on_descriptor_WriteAttributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/AddUser ++void uic_mqtt_dotdot_on_user_credential_add_user( + const char *topic, + const char *message, + const size_t message_length) + { +- if (uic_mqtt_dotdot_descriptor_write_attributes_callback.empty()) { +- return; +- } +- +- if (message_length == 0) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_add_user_callback.empty())) { + return; + } + +@@ -92303,326 +92593,352 @@ void uic_mqtt_dotdot_on_descriptor_WriteAttributes( + return; + } + +- uic_mqtt_dotdot_descriptor_state_t new_state = {}; +- uic_mqtt_dotdot_descriptor_updated_state_t new_updated_state = {}; ++ int16_t user_uniqueid = {}; ++ UserTypeEnum user_type = {}; ++ bool user_active_state = {}; ++ CredRule credential_rule = {}; ++ std::string user_name; ++ int16_t expiring_timeout_minutes = {}; ++ UserNameEncodingType user_name_encoding = {}; + + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + +- uic_mqtt_dotdot_parse_descriptor_write_attributes( ++ ++ uic_mqtt_dotdot_parse_user_credential_add_user( + jsn, +- new_state, +- new_updated_state +- ); ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name, ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "Descriptor", "WriteAttributes"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "AddUser"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddUser", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddUser", ""); + return; + } + +- for (const auto& callback: uic_mqtt_dotdot_descriptor_write_attributes_callback){ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_add_user_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- new_state, +- new_updated_state ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name.c_str(), ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ + ); + } + + } + +-static void uic_mqtt_dotdot_on_descriptor_force_read_attributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/AddUser ++static void uic_mqtt_dotdot_on_generated_user_credential_add_user( + const char *topic, + const char *message, + const size_t message_length) + { +- uint8_t endpoint = 0; +- std::string unid; +- +- if ((message_length == 0) || (uic_mqtt_dotdot_descriptor_force_read_attributes_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_add_user_callback.empty())) { + return; + } + +- if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { + sl_log_debug(LOG_TAG, + "Error parsing UNID / Endpoint ID from topic %s. Ignoring", + topic); + return; + } + +- try { +- uic_mqtt_dotdot_descriptor_updated_state_t force_update = {0}; +- bool trigger_handler = false; ++ int16_t user_uniqueid = {}; ++ UserTypeEnum user_type = {}; ++ bool user_active_state = {}; ++ CredRule credential_rule = {}; ++ std::string user_name; ++ int16_t expiring_timeout_minutes = {}; ++ UserNameEncodingType user_name_encoding = {}; + +- nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- std::vector attributes = jsn["value"].get>(); + +- // Assume all attributes to be read on empty array received +- if (attributes.size() == 0) { +- force_update.device_type_list = true; +- trigger_handler = true; +- } else { +- std::unordered_map supported_attrs = { +- {"DeviceTypeList", &force_update.device_type_list }, +- }; ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- for (auto& attribute : attributes) { +- auto found_attr = supported_attrs.find(attribute); +- if (found_attr != supported_attrs.end()) { +- *(found_attr->second) = true; +- trigger_handler = true; +- } +- } +- } ++ ++ uic_mqtt_dotdot_parse_user_credential_add_user( ++ jsn, ++ user_uniqueid, + +- if (trigger_handler == true) { +- for (const auto& callback: uic_mqtt_dotdot_descriptor_force_read_attributes_callback) { +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- force_update +- ); +- } +- } +- } catch (...) { +- sl_log_debug(LOG_TAG, "Descriptor/Commands/ForceReadAttributes: Unable to parse JSON payload"); +- return; +- } +-} ++ user_type, + +-sl_status_t uic_mqtt_dotdot_descriptor_device_type_list_publish( +- const char *base_topic, +- size_t value_count, +- const DeviceTypeStruct* value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; ++ user_active_state, + +- // This is a variable size array of the same known type. +- // Create an array under the value {"value":[]} +- jsn["value"] = nlohmann::json::array(); ++ credential_rule, + +- for (size_t i = 0; i(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name.c_str(), ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + + +-sl_status_t uic_mqtt_dotdot_descriptor_init() ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/ModifyUser ++void uic_mqtt_dotdot_on_user_credential_modify_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string base_topic = "ucl/by-unid/+/+/"; +- +- std::string subscription_topic; +- if(!uic_mqtt_dotdot_descriptor_write_attributes_callback.empty()) { +- subscription_topic = base_topic + "Descriptor/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_descriptor_WriteAttributes); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_modify_user_callback.empty())) { ++ return; + } + +- if(!uic_mqtt_dotdot_descriptor_force_read_attributes_callback.empty()) { +- subscription_topic = base_topic + "Descriptor/Commands/ForceReadAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_descriptor_force_read_attributes); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Init the attributes for that cluster +- uic_mqtt_dotdot_descriptor_attributes_init(); ++ int16_t user_uniqueid = {}; ++ UserTypeEnum user_type = {}; ++ bool user_active_state = {}; ++ CredRule credential_rule = {}; ++ std::string user_name; ++ int16_t expiring_timeout_minutes = {}; ++ UserNameEncodingType user_name_encoding = {}; + +- uic_mqtt_dotdot_by_group_descriptor_init(); + +- return SL_STATUS_OK; +-} ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +-// Callbacks pointers +-static std::set uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback; +-static std::set uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback; +-static std::set uic_mqtt_dotdot_unify_fan_control_turn_off_callback; +-static std::set uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback; +-static std::set uic_mqtt_dotdot_unify_fan_control_write_attributes_callback; +-static std::set uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback; ++ ++ uic_mqtt_dotdot_parse_user_credential_modify_user( ++ jsn, ++ user_uniqueid, + +-// Callbacks setters +-void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_set(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.insert(callback); ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name, ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", ""); ++ return; + } +-} +-void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_unset(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_clear() +-{ +- uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback() +-{ +- return uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback; +-} + +-void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_set(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.insert(callback); ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_modify_user_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name.c_str(), ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ++ ); + } ++ + } +-void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_unset(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_clear() +-{ +- uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.clear(); +-} +-void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_set(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/ModifyUser ++static void uic_mqtt_dotdot_on_generated_user_credential_modify_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_turn_off_callback.insert(callback); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_modify_user_callback.empty())) { ++ return; + } +-} +-void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_unset(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_turn_off_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_clear() +-{ +- uic_mqtt_dotdot_unify_fan_control_turn_off_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_fan_control_turn_off_callback() +-{ +- return uic_mqtt_dotdot_unify_fan_control_turn_off_callback; +-} + +-void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_set(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.insert(callback); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +-} +-void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_unset(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_clear() +-{ +- uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.clear(); +-} + +-void uic_mqtt_dotdot_set_unify_fan_control_write_attributes_callback( +- const uic_mqtt_dotdot_unify_fan_control_write_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.insert(callback); ++ int16_t user_uniqueid = {}; ++ UserTypeEnum user_type = {}; ++ bool user_active_state = {}; ++ CredRule credential_rule = {}; ++ std::string user_name; ++ int16_t expiring_timeout_minutes = {}; ++ UserNameEncodingType user_name_encoding = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_modify_user( ++ jsn, ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name, ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", ""); ++ return; + } +-} +-void uic_mqtt_dotdot_unset_unify_fan_control_write_attributes_callback( +- const uic_mqtt_dotdot_unify_fan_control_write_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_fan_control_write_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_fan_control_write_attributes_callback() +-{ +- return uic_mqtt_dotdot_unify_fan_control_write_attributes_callback; +-} + +-void uic_mqtt_dotdot_set_unify_fan_control_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.insert(callback); ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_modify_user_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ user_type, ++ ++ user_active_state, ++ ++ credential_rule, ++ ++ user_name.c_str(), ++ ++ expiring_timeout_minutes, ++ ++ user_name_encoding ++ ++ ); + } + } +-void uic_mqtt_dotdot_unset_unify_fan_control_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_fan_control_force_read_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.clear(); +-} + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/SetFanMode +-void uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteUser ++void uic_mqtt_dotdot_on_user_credential_delete_user( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_user_callback.empty())) { + return; + } + +@@ -92635,7 +92951,7 @@ void uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode( + return; + } + +- ZWaveFanModeEnum fan_mode = {}; ++ int16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -92643,45 +92959,45 @@ void uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ uic_mqtt_dotdot_parse_user_credential_delete_user( + jsn, +- fan_mode ++ user_uniqueid + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteUser"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", ""); + return; + } + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_user_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- fan_mode ++ user_uniqueid + + ); + } + + } + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/GeneratedCommands/SetFanMode +-static void uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteUser ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_user( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_user_callback.empty())) { + return; + } + +@@ -92694,7 +93010,7 @@ static void uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode( + return; + } + +- ZWaveFanModeEnum fan_mode = {}; ++ int16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -92702,46 +93018,46 @@ static void uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ uic_mqtt_dotdot_parse_user_credential_delete_user( + jsn, +- fan_mode ++ user_uniqueid + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteUser"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", ""); + return; + } + + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_user_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- fan_mode ++ user_uniqueid + + ); + } + } + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/TurnOff +-void uic_mqtt_dotdot_on_unify_fan_control_turn_off( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/AddCredential ++void uic_mqtt_dotdot_on_user_credential_add_credential( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_turn_off_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_add_credential_callback.empty())) { + return; + } + +@@ -92754,6 +93070,10 @@ void uic_mqtt_dotdot_on_unify_fan_control_turn_off( + return; + } + ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ std::string credential_data; + + + nlohmann::json jsn; +@@ -92761,38 +93081,57 @@ void uic_mqtt_dotdot_on_unify_fan_control_turn_off( + jsn = nlohmann::json::parse(std::string(message)); + + ++ uic_mqtt_dotdot_parse_user_credential_add_credential( ++ jsn, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data ++ ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "AddCredential"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", ""); + return; + } + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_turn_off_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_add_credential_callback){ + callback( + static_cast(unid.c_str()), + endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data.c_str() ++ + ); + } + + } + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/GeneratedCommands/TurnOff +-static void uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/AddCredential ++static void uic_mqtt_dotdot_on_generated_user_credential_add_credential( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_add_credential_callback.empty())) { + return; + } + +@@ -92805,6 +93144,10 @@ static void uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off( + return; + } + ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ std::string credential_data; + + + nlohmann::json jsn; +@@ -92812,43 +93155,58 @@ static void uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off( + jsn = nlohmann::json::parse(std::string(message)); + + ++ uic_mqtt_dotdot_parse_user_credential_add_credential( ++ jsn, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data ++ ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "AddCredential"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", ""); + return; + } + + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_add_credential_callback){ + callback( + static_cast(unid.c_str()), + endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data.c_str() ++ + ); + } + } + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/WriteAttributes +-void uic_mqtt_dotdot_on_unify_fan_control_WriteAttributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/ModifyCredential ++void uic_mqtt_dotdot_on_user_credential_modify_credential( + const char *topic, + const char *message, + const size_t message_length) + { +- if (uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.empty()) { +- return; +- } +- +- if (message_length == 0) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_modify_credential_callback.empty())) { + return; + } + +@@ -92861,419 +93219,333 @@ void uic_mqtt_dotdot_on_unify_fan_control_WriteAttributes( + return; + } + +- uic_mqtt_dotdot_unify_fan_control_state_t new_state = {}; +- uic_mqtt_dotdot_unify_fan_control_updated_state_t new_updated_state = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ std::string credential_data; + + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + +- uic_mqtt_dotdot_parse_unify_fan_control_write_attributes( ++ ++ uic_mqtt_dotdot_parse_user_credential_modify_credential( + jsn, +- new_state, +- new_updated_state +- ); ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data ++ ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "WriteAttributes"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyCredential"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "WriteAttributes", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "WriteAttributes", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", ""); + return; + } + +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_write_attributes_callback){ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_modify_credential_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- new_state, +- new_updated_state ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data.c_str() ++ + ); + } + + } + +-static void uic_mqtt_dotdot_on_unify_fan_control_force_read_attributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/ModifyCredential ++static void uic_mqtt_dotdot_on_generated_user_credential_modify_credential( + const char *topic, + const char *message, + const size_t message_length) + { +- uint8_t endpoint = 0; +- std::string unid; +- +- if ((message_length == 0) || (uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_modify_credential_callback.empty())) { + return; + } + +- if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { + sl_log_debug(LOG_TAG, + "Error parsing UNID / Endpoint ID from topic %s. Ignoring", + topic); + return; + } + ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ std::string credential_data; ++ ++ ++ nlohmann::json jsn; + try { +- uic_mqtt_dotdot_unify_fan_control_updated_state_t force_update = {0}; +- bool trigger_handler = false; ++ jsn = nlohmann::json::parse(std::string(message)); + +- nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- std::vector attributes = jsn["value"].get>(); ++ ++ uic_mqtt_dotdot_parse_user_credential_modify_credential( ++ jsn, ++ user_uniqueid, + +- // Assume all attributes to be read on empty array received +- if (attributes.size() == 0) { +- force_update.z_wave_fan_mode = true; +- force_update.z_wave_supported_fan_mode = true; +- force_update.z_wave_fan_state = true; +- trigger_handler = true; +- } else { +- std::unordered_map supported_attrs = { +- {"ZWaveFanMode", &force_update.z_wave_fan_mode }, +- {"ZWaveSupportedFanMode", &force_update.z_wave_supported_fan_mode }, +- {"ZWaveFanState", &force_update.z_wave_fan_state }, +- }; ++ credential_type, + +- for (auto& attribute : attributes) { +- auto found_attr = supported_attrs.find(attribute); +- if (found_attr != supported_attrs.end()) { +- *(found_attr->second) = true; +- trigger_handler = true; +- } +- } +- } ++ credential_slot, + +- if (trigger_handler == true) { +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback) { +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- force_update +- ); +- } +- } +- } catch (...) { +- sl_log_debug(LOG_TAG, "UnifyFanControl/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ credential_data ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyCredential"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", ""); + return; + } +-} +- +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_mode_publish( +- const char *base_topic, +- ZWaveFanModeEnum value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; + +- // This is a single value + +- #ifdef UNIFY_FAN_CONTROL_Z_WAVE_FAN_MODE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_fan_control_z_wave_fan_mode_get_enum_value_name((uint32_t)value); +- #elif defined(Z_WAVE_FAN_MODE_ENUM_ENUM_NAME_AVAILABLE) +- jsn["value"] = z_wave_fan_mode_enum_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_FAN_CONTROL_Z_WAVE_FAN_MODE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif + + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); +- } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveFanMode", e.what()); +- return SL_STATUS_OK; ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_modify_credential_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_data.c_str() ++ ++ ); + } ++} + + +- std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveFanMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteCredential ++void uic_mqtt_dotdot_on_user_credential_delete_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_credential_callback.empty())) { ++ return; + } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyFanControl/Attributes/ZWaveFanMode"; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); +- } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_supported_fan_mode_publish( +- const char *base_topic, +- uint16_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ + nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- // This is a single value ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_credential( ++ jsn, ++ user_uniqueid, + +- nlohmann::json bitmap_values = UnifyFanControlZWaveSupportedFanMode.get_bitmap_values_as_json_tree((uint32_t)value); +- jsn["value"] = bitmap_values; ++ credential_type, + ++ credential_slot ++ ); + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteCredential"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveSupportedFanMode", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", ""); ++ return; + } + +- boost::replace_all(payload_str, "\"true\"", "true"); +- boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveSupportedFanMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_credential_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_supported_fan_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteCredential ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyFanControl/Attributes/ZWaveSupportedFanMode"; +- +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_credential_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_state_publish( +- const char *base_topic, +- ZWaveFanStateEnum value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ ++ + nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- // This is a single value ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_credential( ++ jsn, ++ user_uniqueid, + +- #ifdef UNIFY_FAN_CONTROL_Z_WAVE_FAN_STATE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_fan_control_z_wave_fan_state_get_enum_value_name((uint32_t)value); +- #elif defined(Z_WAVE_FAN_STATE_ENUM_ENUM_NAME_AVAILABLE) +- jsn["value"] = z_wave_fan_state_enum_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_FAN_CONTROL_Z_WAVE_FAN_STATE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ credential_type, + ++ credential_slot ++ ); + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteCredential"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveFanState", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveFanState"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_state_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyFanControl/Attributes/ZWaveFanState"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_credential_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + + +-sl_status_t uic_mqtt_dotdot_unify_fan_control_init() ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteAllUsers ++void uic_mqtt_dotdot_on_user_credential_delete_all_users( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string base_topic = "ucl/by-unid/+/+/"; +- +- std::string subscription_topic; +- if(!uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_WriteAttributes); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_all_users_callback.empty())) { ++ return; + } + +- if(!uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/Commands/ForceReadAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_force_read_attributes); +- } +- if (!uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/Commands/SetFanMode"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode); +- } +- if (!uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/GeneratedCommands/SetFanMode"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode); +- } +- if (!uic_mqtt_dotdot_unify_fan_control_turn_off_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/Commands/TurnOff"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_turn_off); +- } +- if (!uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.empty()) { +- subscription_topic = base_topic + "UnifyFanControl/GeneratedCommands/TurnOff"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Init the attributes for that cluster +- uic_mqtt_dotdot_unify_fan_control_attributes_init(); + +- uic_mqtt_dotdot_by_group_unify_fan_control_init(); + +- return SL_STATUS_OK; +-} ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +-// Callbacks pointers +-static std::set uic_mqtt_dotdot_unify_thermostat_write_attributes_callback; +-static std::set uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback; ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllUsers"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", ""); ++ return; ++ } + +-// Callbacks setters + +-void uic_mqtt_dotdot_set_unify_thermostat_write_attributes_callback( +- const uic_mqtt_dotdot_unify_thermostat_write_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.insert(callback); +- } +-} +-void uic_mqtt_dotdot_unset_unify_thermostat_write_attributes_callback( +- const uic_mqtt_dotdot_unify_thermostat_write_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_thermostat_write_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_thermostat_write_attributes_callback() +-{ +- return uic_mqtt_dotdot_unify_thermostat_write_attributes_callback; +-} + +-void uic_mqtt_dotdot_set_unify_thermostat_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.insert(callback); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_users_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +-} +-void uic_mqtt_dotdot_unset_unify_thermostat_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_thermostat_force_read_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.clear(); +-} + ++} + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyThermostat/Commands/WriteAttributes +-void uic_mqtt_dotdot_on_unify_thermostat_WriteAttributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteAllUsers ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_users( + const char *topic, + const char *message, + const size_t message_length) + { +- if (uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.empty()) { +- return; +- } +- +- if (message_length == 0) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback.empty())) { + return; + } + +@@ -93286,469 +93558,387 @@ void uic_mqtt_dotdot_on_unify_thermostat_WriteAttributes( + return; + } + +- uic_mqtt_dotdot_unify_thermostat_state_t new_state = {}; +- uic_mqtt_dotdot_unify_thermostat_updated_state_t new_updated_state = {}; + + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + +- uic_mqtt_dotdot_parse_unify_thermostat_write_attributes( +- jsn, +- new_state, +- new_updated_state +- ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyThermostat", "WriteAttributes"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllUsers"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat", "WriteAttributes", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat", "WriteAttributes", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", ""); + return; + } + +- for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_write_attributes_callback){ ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback){ + callback( + static_cast(unid.c_str()), + endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- new_state, +- new_updated_state ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL + ); + } +- + } + +-static void uic_mqtt_dotdot_on_unify_thermostat_force_read_attributes( ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentials ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials( + const char *topic, + const char *message, + const size_t message_length) + { +- uint8_t endpoint = 0; +- std::string unid; +- +- if ((message_length == 0) || (uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_all_credentials_callback.empty())) { + return; + } + +- if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { + sl_log_debug(LOG_TAG, + "Error parsing UNID / Endpoint ID from topic %s. Ignoring", + topic); + return; + } + ++ ++ ++ nlohmann::json jsn; + try { +- uic_mqtt_dotdot_unify_thermostat_updated_state_t force_update = {0}; +- bool trigger_handler = false; ++ jsn = nlohmann::json::parse(std::string(message)); + +- nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- std::vector attributes = jsn["value"].get>(); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentials"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", ""); ++ return; ++ } + +- // Assume all attributes to be read on empty array received +- if (attributes.size() == 0) { +- force_update.thermostat_mode = true; +- force_update.supported_thermostat_mode = true; +- force_update.operating_state = true; +- trigger_handler = true; +- } else { +- std::unordered_map supported_attrs = { +- {"ThermostatMode", &force_update.thermostat_mode }, +- {"SupportedThermostatMode", &force_update.supported_thermostat_mode }, +- {"OperatingState", &force_update.operating_state }, +- }; + +- for (auto& attribute : attributes) { +- auto found_attr = supported_attrs.find(attribute); +- if (found_attr != supported_attrs.end()) { +- *(found_attr->second) = true; +- trigger_handler = true; +- } +- } +- } + +- if (trigger_handler == true) { +- for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback) { +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- force_update +- ); +- } +- } +- } catch (...) { +- sl_log_debug(LOG_TAG, "UnifyThermostat/Commands/ForceReadAttributes: Unable to parse JSON payload"); +- return; ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_thermostat_mode_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteAllCredentials ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback.empty())) { ++ return; ++ } + +- // This is a single value ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- #ifdef UNIFY_THERMOSTAT_THERMOSTAT_MODE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_thermostat_thermostat_mode_get_enum_value_name((uint32_t)value); +- #elif defined(ENUM8_ENUM_NAME_AVAILABLE) +- jsn["value"] = enum8_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_THERMOSTAT_THERMOSTAT_MODE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif + + +- std::string payload_str; ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentials"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/ThermostatMode", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/ThermostatMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_thermostat_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyThermostat/Attributes/ThermostatMode"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_supported_thermostat_mode_publish( +- const char *base_topic, +- uint16_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsByType ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback.empty())) { ++ return; ++ } + +- // This is a single value ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- nlohmann::json bitmap_values = UnifyThermostatSupportedThermostatMode.get_bitmap_values_as_json_tree((uint32_t)value); +- jsn["value"] = bitmap_values; ++ CredType credential_type = {}; + + +- std::string payload_str; ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_by_type( ++ jsn, ++ credential_type ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsByType"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/SupportedThermostatMode", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", ""); ++ return; + } + +- boost::replace_all(payload_str, "\"true\"", "true"); +- boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/SupportedThermostatMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_supported_thermostat_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteAllCredentialsByType ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyThermostat/Attributes/SupportedThermostatMode"; +- +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_operating_state_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; ++ CredType credential_type = {}; + +- // This is a single value + +- #ifdef UNIFY_THERMOSTAT_OPERATING_STATE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_thermostat_operating_state_get_enum_value_name((uint32_t)value); +- #elif defined(ENUM8_ENUM_NAME_AVAILABLE) +- jsn["value"] = enum8_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_THERMOSTAT_OPERATING_STATE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_by_type( ++ jsn, ++ credential_type ++ ); + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsByType"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/OperatingState", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/OperatingState"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_operating_state_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyThermostat/Attributes/OperatingState"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + + +-sl_status_t uic_mqtt_dotdot_unify_thermostat_init() ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsForUser ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string base_topic = "ucl/by-unid/+/+/"; +- +- std::string subscription_topic; +- if(!uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyThermostat/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_thermostat_WriteAttributes); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback.empty())) { ++ return; + } + +- if(!uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyThermostat/Commands/ForceReadAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_thermostat_force_read_attributes); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Init the attributes for that cluster +- uic_mqtt_dotdot_unify_thermostat_attributes_init(); ++ int16_t user_uniqueid = {}; + +- uic_mqtt_dotdot_by_group_unify_thermostat_init(); + +- return SL_STATUS_OK; +-} ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +-// Callbacks pointers +-static std::set uic_mqtt_dotdot_unify_humidity_control_mode_set_callback; +-static std::set uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback; +-static std::set uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback; +-static std::set uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback; +-static std::set uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback; +-static std::set uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback; ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( ++ jsn, ++ user_uniqueid ++ ); + +-// Callbacks setters +-void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.insert(callback); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", ""); ++ return; + } +-} +-void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_clear() +-{ +- uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_humidity_control_mode_set_callback() +-{ +- return uic_mqtt_dotdot_unify_humidity_control_mode_set_callback; +-} + +-void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.insert(callback); ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid ++ ++ ); + } ++ + } +-void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_clear() +-{ +- uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.clear(); +-} +-void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteAllCredentialsForUser ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_for_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.insert(callback); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback.empty())) { ++ return; + } +-} +-void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_clear() +-{ +- uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback() +-{ +- return uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback; +-} + +-void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.insert(callback); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +-} +-void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.erase(callback); +-} +-void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_clear() +-{ +- uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.clear(); +-} + +-void uic_mqtt_dotdot_set_unify_humidity_control_write_attributes_callback( +- const uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.insert(callback); ++ int16_t user_uniqueid = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( ++ jsn, ++ user_uniqueid ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", ""); ++ return; + } +-} +-void uic_mqtt_dotdot_unset_unify_humidity_control_write_attributes_callback( +- const uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_humidity_control_write_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.clear(); +-} +-std::set& get_uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback() +-{ +- return uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback; +-} + +-void uic_mqtt_dotdot_set_unify_humidity_control_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback_t callback) +-{ +- if (callback != nullptr) { +- uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.insert(callback); ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid ++ ++ ); + } + } +-void uic_mqtt_dotdot_unset_unify_humidity_control_force_read_attributes_callback( +- const uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback_t callback) +-{ +- uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.erase(callback); +-} +-void uic_mqtt_dotdot_clear_unify_humidity_control_force_read_attributes_callbacks() +-{ +- uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.clear(); +-} + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/ModeSet +-void uic_mqtt_dotdot_on_unify_humidity_control_mode_set( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsForUserByType ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user_by_type( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback.empty())) { + return; + } + +@@ -93761,7 +93951,8 @@ void uic_mqtt_dotdot_on_unify_humidity_control_mode_set( + return; + } + +- ModeType mode = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; + + + nlohmann::json jsn; +@@ -93769,45 +93960,49 @@ void uic_mqtt_dotdot_on_unify_humidity_control_mode_set( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_humidity_control_mode_set( ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( + jsn, +- mode ++ user_uniqueid, ++ ++ credential_type + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "ModeSet"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUserByType"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", ""); + return; + } + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_mode_set_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- mode ++ user_uniqueid, ++ ++ credential_type + + ); + } + + } + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/GeneratedCommands/ModeSet +-static void uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType ++static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_for_user_by_type( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback.empty())) { + return; + } + +@@ -93820,7 +94015,8 @@ static void uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set( + return; + } + +- ModeType mode = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; + + + nlohmann::json jsn; +@@ -93828,46 +94024,50 @@ static void uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_humidity_control_mode_set( ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( + jsn, +- mode ++ user_uniqueid, ++ ++ credential_type + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "ModeSet"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUserByType"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", ""); + return; + } + + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- mode ++ user_uniqueid, ++ ++ credential_type + + ); + } + } + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/SetpointSet +-void uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStartAdd ++void uic_mqtt_dotdot_on_user_credential_credential_learn_start_add( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback.empty())) { + return; + } + +@@ -93880,10 +94080,10 @@ void uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set( + return; + } + +- SetpointType type = {}; +- uint8_t precision = {}; +- uint8_t scale = {}; +- int32_t value = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ int8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -93891,57 +94091,57 @@ void uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + jsn, +- type, ++ user_uniqueid, + +- precision, ++ credential_type, + +- scale, ++ credential_slot, + +- value ++ credential_learn_timeout + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "SetpointSet"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartAdd"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", ""); + return; + } + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- type, ++ user_uniqueid, + +- precision, ++ credential_type, + +- scale, ++ credential_slot, + +- value ++ credential_learn_timeout + + ); + } + + } + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/GeneratedCommands/SetpointSet +-static void uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/CredentialLearnStartAdd ++static void uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_add( + const char *topic, + const char *message, + const size_t message_length) + { +- if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback.empty())) { + return; + } + +@@ -93954,10 +94154,10 @@ static void uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set( + return; + } + +- SetpointType type = {}; +- uint8_t precision = {}; +- uint8_t scale = {}; +- int32_t value = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ int8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -93965,62 +94165,58 @@ static void uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set( + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + jsn, +- type, ++ user_uniqueid, + +- precision, ++ credential_type, + +- scale, ++ credential_slot, + +- value ++ credential_learn_timeout + ); + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "SetpointSet"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartAdd"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", ""); + return; + } + + + + +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback){ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- type, ++ user_uniqueid, + +- precision, ++ credential_type, + +- scale, ++ credential_slot, + +- value ++ credential_learn_timeout + + ); + } + } + + +-// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/WriteAttributes +-void uic_mqtt_dotdot_on_unify_humidity_control_WriteAttributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStartModify ++void uic_mqtt_dotdot_on_user_credential_credential_learn_start_modify( + const char *topic, + const char *message, + const size_t message_length) + { +- if (uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.empty()) { +- return; +- } +- +- if (message_length == 0) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback.empty())) { + return; + } + +@@ -94033,975 +94229,1154 @@ void uic_mqtt_dotdot_on_unify_humidity_control_WriteAttributes( + return; + } + +- uic_mqtt_dotdot_unify_humidity_control_state_t new_state = {}; +- uic_mqtt_dotdot_unify_humidity_control_updated_state_t new_updated_state = {}; ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ int8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + +- uic_mqtt_dotdot_parse_unify_humidity_control_write_attributes( ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( + jsn, +- new_state, +- new_updated_state +- ); ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_learn_timeout ++ ); ++ + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "WriteAttributes"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartModify"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "WriteAttributes", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "WriteAttributes", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", ""); + return; + } + +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback){ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback){ + callback( + static_cast(unid.c_str()), + endpoint, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- new_state, +- new_updated_state ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_learn_timeout ++ + ); + } + + } + +-static void uic_mqtt_dotdot_on_unify_humidity_control_force_read_attributes( ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/CredentialLearnStartModify ++static void uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_modify( + const char *topic, + const char *message, + const size_t message_length) + { +- uint8_t endpoint = 0; +- std::string unid; +- +- if ((message_length == 0) || (uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.empty())) { ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback.empty())) { + return; + } + +- if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { + sl_log_debug(LOG_TAG, + "Error parsing UNID / Endpoint ID from topic %s. Ignoring", + topic); + return; + } + +- try { +- uic_mqtt_dotdot_unify_humidity_control_updated_state_t force_update = {0}; +- bool trigger_handler = false; +- +- nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- std::vector attributes = jsn["value"].get>(); +- +- // Assume all attributes to be read on empty array received +- if (attributes.size() == 0) { +- force_update.reporting_mode = true; +- force_update.supported_reporting_mode = true; +- force_update.current_state = true; +- force_update.supported_set_points = true; +- force_update.humidifier_setpoint_min = true; +- force_update.humidifier_setpoint_max = true; +- force_update.humidifier_setpoint = true; +- force_update.humidifier_setpoint_scale = true; +- force_update.humidifier_setpoint_precision = true; +- force_update.dehumidifier_setpoint_min = true; +- force_update.dehumidifier_setpoint_max = true; +- force_update.dehumidifier_setpoint = true; +- force_update.dehumidifier_setpoint_scale = true; +- force_update.dehumidifier_setpoint_precision = true; +- force_update.auto_setpoint_min = true; +- force_update.auto_setpoint_max = true; +- force_update.auto_setpoint = true; +- force_update.auto_setpoint_scale = true; +- force_update.auto_setpoint_precision = true; +- trigger_handler = true; +- } else { +- std::unordered_map supported_attrs = { +- {"ReportingMode", &force_update.reporting_mode }, +- {"SupportedReportingMode", &force_update.supported_reporting_mode }, +- {"CurrentState", &force_update.current_state }, +- {"SupportedSetPoints", &force_update.supported_set_points }, +- {"HumidifierSetpointMin", &force_update.humidifier_setpoint_min }, +- {"HumidifierSetpointMax", &force_update.humidifier_setpoint_max }, +- {"HumidifierSetpoint", &force_update.humidifier_setpoint }, +- {"HumidifierSetpointScale", &force_update.humidifier_setpoint_scale }, +- {"HumidifierSetpointPrecision", &force_update.humidifier_setpoint_precision }, +- {"DehumidifierSetpointMin", &force_update.dehumidifier_setpoint_min }, +- {"DehumidifierSetpointMax", &force_update.dehumidifier_setpoint_max }, +- {"DehumidifierSetpoint", &force_update.dehumidifier_setpoint }, +- {"DehumidifierSetpointScale", &force_update.dehumidifier_setpoint_scale }, +- {"DehumidifierSetpointPrecision", &force_update.dehumidifier_setpoint_precision }, +- {"AutoSetpointMin", &force_update.auto_setpoint_min }, +- {"AutoSetpointMax", &force_update.auto_setpoint_max }, +- {"AutoSetpoint", &force_update.auto_setpoint }, +- {"AutoSetpointScale", &force_update.auto_setpoint_scale }, +- {"AutoSetpointPrecision", &force_update.auto_setpoint_precision }, +- }; +- +- for (auto& attribute : attributes) { +- auto found_attr = supported_attrs.find(attribute); +- if (found_attr != supported_attrs.end()) { +- *(found_attr->second) = true; +- trigger_handler = true; +- } +- } +- } ++ int16_t user_uniqueid = {}; ++ CredType credential_type = {}; ++ int16_t credential_slot = {}; ++ int8_t credential_learn_timeout = {}; + +- if (trigger_handler == true) { +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback) { +- callback( +- static_cast(unid.c_str()), +- endpoint, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, +- force_update +- ); +- } +- } +- } catch (...) { +- sl_log_debug(LOG_TAG, "UnifyHumidityControl/Commands/ForceReadAttributes: Unable to parse JSON payload"); +- return; +- } +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_reporting_mode_publish( +- const char *base_topic, +- ModeType value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ + nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- // This is a single value ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( ++ jsn, ++ user_uniqueid, + +- #ifdef UNIFY_HUMIDITY_CONTROL_REPORTING_MODE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_humidity_control_reporting_mode_get_enum_value_name((uint32_t)value); +- #elif defined(MODE_TYPE_ENUM_NAME_AVAILABLE) +- jsn["value"] = mode_type_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_REPORTING_MODE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ credential_type, + ++ credential_slot, + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ credential_learn_timeout ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartModify"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/ReportingMode", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/ReportingMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_reporting_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/ReportingMode"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid, ++ ++ credential_type, ++ ++ credential_slot, ++ ++ credential_learn_timeout ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_reporting_mode_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStop ++void uic_mqtt_dotdot_on_user_credential_credential_learn_stop( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_credential_learn_stop_callback.empty())) { ++ return; ++ } + +- // This is a single value ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- nlohmann::json bitmap_values = UnifyHumidityControlSupportedReportingMode.get_bitmap_values_as_json_tree((uint32_t)value); +- jsn["value"] = bitmap_values; + + +- std::string payload_str; ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStop"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/SupportedReportingMode", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", ""); ++ return; + } + +- boost::replace_all(payload_str, "\"true\"", "true"); +- boost::replace_all(payload_str, "\"false\"", "false"); +- +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/SupportedReportingMode"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_reporting_mode_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/SupportedReportingMode"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_stop_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return SL_STATUS_OK; ++ + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_current_state_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/CredentialLearnStop ++static void uic_mqtt_dotdot_on_generated_user_credential_credential_learn_stop( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback.empty())) { ++ return; ++ } + +- // This is a single value ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- #ifdef UNIFY_HUMIDITY_CONTROL_CURRENT_STATE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_humidity_control_current_state_get_enum_value_name((uint32_t)value); +- #elif defined(ENUM8_ENUM_NAME_AVAILABLE) +- jsn["value"] = enum8_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_CURRENT_STATE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif + + +- std::string payload_str; ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStop"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/CurrentState", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/CurrentState"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_current_state_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/CurrentState"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/CredentialAssociation ++void uic_mqtt_dotdot_on_user_credential_credential_association( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_credential_association_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_set_points_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ ++ CredType credential_type = {}; ++ int16_t source_user_uniqueid = {}; ++ int16_t source_credential_slot = {}; ++ int16_t destination_user_uniqueid = {}; ++ int16_t destination_credential_slot = {}; ++ ++ + nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- // This is a single value ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_association( ++ jsn, ++ credential_type, + +- nlohmann::json bitmap_values = UnifyHumidityControlSupportedSetPoints.get_bitmap_values_as_json_tree((uint32_t)value); +- jsn["value"] = bitmap_values; ++ source_user_uniqueid, + ++ source_credential_slot, + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ destination_user_uniqueid, ++ ++ destination_credential_slot ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialAssociation"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/SupportedSetPoints", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", ""); ++ return; + } + +- boost::replace_all(payload_str, "\"true\"", "true"); +- boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/SupportedSetPoints"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_association_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type, ++ ++ source_user_uniqueid, ++ ++ source_credential_slot, ++ ++ destination_user_uniqueid, ++ ++ destination_credential_slot ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_set_points_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/CredentialAssociation ++static void uic_mqtt_dotdot_on_generated_user_credential_credential_association( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/SupportedSetPoints"; +- +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_credential_association_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_min_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ ++ CredType credential_type = {}; ++ int16_t source_user_uniqueid = {}; ++ int16_t source_credential_slot = {}; ++ int16_t destination_user_uniqueid = {}; ++ int16_t destination_credential_slot = {}; ++ ++ + nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- // This is a single value ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_association( ++ jsn, ++ credential_type, + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,5,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,5,value); +- }else{ +- jsn["value"] = value; +- } ++ source_user_uniqueid, + ++ source_credential_slot, + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ destination_user_uniqueid, ++ ++ destination_credential_slot ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialAssociation"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointMin", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointMin"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_min_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/HumidifierSetpointMin"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_credential_association_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type, ++ ++ source_user_uniqueid, ++ ++ source_credential_slot, ++ ++ destination_user_uniqueid, ++ ++ destination_credential_slot ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_max_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; + +- // This is a single value ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/GetUserChecksum ++void uic_mqtt_dotdot_on_user_credential_get_user_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_get_user_checksum_callback.empty())) { ++ return; ++ } + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,6,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,6,value); +- }else{ +- jsn["value"] = value; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + ++ int16_t user_uniqueid = {}; + +- std::string payload_str; ++ ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_get_user_checksum( ++ jsn, ++ user_uniqueid ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetUserChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointMax", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointMax"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_user_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_max_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/GetUserChecksum ++static void uic_mqtt_dotdot_on_generated_user_credential_get_user_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/HumidifierSetpointMax"; +- +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; ++ int16_t user_uniqueid = {}; + +- // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,7,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,7,value); +- }else{ +- jsn["value"] = value; +- } ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + ++ ++ uic_mqtt_dotdot_parse_user_credential_get_user_checksum( ++ jsn, ++ user_uniqueid ++ ); + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetUserChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpoint", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpoint"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/HumidifierSetpoint"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ user_uniqueid ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_publish( +- const char *base_topic, +- ScaleType value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/GetCredentialChecksum ++void uic_mqtt_dotdot_on_user_credential_get_credential_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_get_credential_checksum_callback.empty())) { ++ return; ++ } + +- // This is a single value ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- #ifdef UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_SCALE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_humidity_control_humidifier_setpoint_scale_get_enum_value_name((uint32_t)value); +- #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) +- jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_SCALE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ CredType credential_type = {}; + + +- std::string payload_str; ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_get_credential_checksum( ++ jsn, ++ credential_type ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetCredentialChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointScale", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointScale"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_credential_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/GetCredentialChecksum ++static void uic_mqtt_dotdot_on_generated_user_credential_get_credential_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/HumidifierSetpointScale"; +- +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback.empty())) { ++ return; + } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return SL_STATUS_OK; +-} +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( +- const char *base_topic, +- uint8_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; ++ CredType credential_type = {}; + +- // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,9,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,9,value); +- }else{ +- jsn["value"] = value; +- } ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + ++ ++ uic_mqtt_dotdot_parse_user_credential_get_credential_checksum( ++ jsn, ++ credential_type ++ ); + +- std::string payload_str; +- try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetCredentialChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointPrecision", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointPrecision"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/HumidifierSetpointPrecision"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ credential_type ++ ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_min_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; + +- // This is a single value ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/GetAllUsersChecksum ++void uic_mqtt_dotdot_on_user_credential_get_all_users_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback.empty())) { ++ return; ++ } + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,10,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,10,value); +- }else{ +- jsn["value"] = value; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + + +- std::string payload_str; ++ ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetAllUsersChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointMin", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMin"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} +- +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_min_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMin"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return SL_STATUS_OK; ++ + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_max_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/GetAllUsersChecksum ++static void uic_mqtt_dotdot_on_generated_user_credential_get_all_users_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- nlohmann::json jsn; +- +- // This is a single value ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback.empty())) { ++ return; ++ } + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,11,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,11,value); +- }else{ +- jsn["value"] = value; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + + +- std::string payload_str; ++ ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetAllUsersChecksum"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointMax", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMax"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- return SL_STATUS_OK; +-} + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_max_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) +-{ +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMax"; + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); +- } +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return SL_STATUS_OK; + } +-// clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_publish( +- const char *base_topic, +- int32_t value, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type +-) +-{ +- nlohmann::json jsn; + +- // This is a single value ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/SetAdminPINCode ++void uic_mqtt_dotdot_on_user_credential_set_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback.empty())) { ++ return; ++ } + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,12,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,12,value); +- }else{ +- jsn["value"] = value; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + ++ std::string pin_code; + +- std::string payload_str; ++ ++ nlohmann::json jsn; + try { +- // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters +- payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_set_admin_pin_code( ++ jsn, ++ pin_code ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "SetAdminPINCode"); ++ return; + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpoint", e.what()); +- return SL_STATUS_OK; ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", ""); ++ return; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpoint"; +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) +- { +- std::string topic_desired = topic + "/Desired"; +- uic_mqtt_publish(topic_desired.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } +- if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) +- { +- std::string topic_reported = topic + "/Reported"; +- uic_mqtt_publish(topic_reported.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ pin_code.c_str() ++ ++ ); + } +- return SL_STATUS_OK; ++ + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_unretain( +- const char *base_topic, +- uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/SetAdminPINCode ++static void uic_mqtt_dotdot_on_generated_user_credential_set_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- // clang-format on +- std::string topic +- = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/DehumidifierSetpoint"; ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback.empty())) { ++ return; ++ } + +- if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) +- || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string pin_code; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_set_admin_pin_code( ++ jsn, ++ pin_code ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "SetAdminPINCode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", ""); ++ return; ++ } ++ ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ pin_code.c_str() ++ ++ ); ++ } ++} ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/DeactivateAdminPINCode ++void uic_mqtt_dotdot_on_user_credential_deactivate_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback.empty())) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeactivateAdminPINCode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", ""); ++ return; ++ } ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/GeneratedCommands/DeactivateAdminPINCode ++static void uic_mqtt_dotdot_on_generated_user_credential_deactivate_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback.empty())) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeactivateAdminPINCode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", ""); ++ return; ++ } ++ ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); ++ } ++} ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UserCredential/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_user_credential_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (uic_mqtt_dotdot_user_credential_write_attributes_callback.empty()) { ++ return; ++ } ++ ++ if (message_length == 0) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_state_t new_state = {}; ++ uic_mqtt_dotdot_user_credential_updated_state_t new_updated_state = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_user_credential_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "WriteAttributes", ""); ++ return; ++ } ++ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); ++ } ++ ++} ++ ++static void uic_mqtt_dotdot_on_user_credential_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ uint8_t endpoint = 0; ++ std::string unid; ++ ++ if ((message_length == 0) || (uic_mqtt_dotdot_user_credential_force_read_attributes_callback.empty())) { ++ return; ++ } ++ ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ try { ++ uic_mqtt_dotdot_user_credential_updated_state_t force_update = {0}; ++ bool trigger_handler = false; ++ ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); ++ ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.supported_user_unique_identifiers = true; ++ force_update.supported_credential_rules = true; ++ force_update.supported_credential_types = true; ++ force_update.supported_user_types = true; ++ force_update.support_credential_checksum = true; ++ force_update.support_admin_pin_code = true; ++ force_update.support_admin_pin_code_deactivation = true; ++ force_update.admin_pin_code = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"SupportedUserUniqueIdentifiers", &force_update.supported_user_unique_identifiers }, ++ {"SupportedCredentialRules", &force_update.supported_credential_rules }, ++ {"SupportedCredentialTypes", &force_update.supported_credential_types }, ++ {"SupportedUserTypes", &force_update.supported_user_types }, ++ {"SupportCredentialChecksum", &force_update.support_credential_checksum }, ++ {"SupportAdminPinCode", &force_update.support_admin_pin_code }, ++ {"SupportAdminPinCodeDeactivation", &force_update.support_admin_pin_code_deactivation }, ++ {"AdminPinCode", &force_update.admin_pin_code }, ++ }; ++ ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } ++ } ++ ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } ++ } ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "UserCredential/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; ++ } ++} ++ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( ++ const char *base_topic, ++ int16_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) ++{ ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64776,0,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64776,0,value); ++ }else{ ++ jsn["value"] = value; ++ } ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportedUserUniqueIdentifiers", e.what()); ++ return SL_STATUS_OK; ++ } ++ ++ ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportedUserUniqueIdentifiers"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; ++} ++ ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++{ ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UserCredential/Attributes/SupportedUserUniqueIdentifiers"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { + std::string topic_desired = topic + "/Desired"; + uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); + } +@@ -95014,9 +95389,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_unretai + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_rules_publish( + const char *base_topic, +- ScaleType value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95024,14 +95399,8 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_p + + // This is a single value + +- #ifdef UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_SCALE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_humidity_control_dehumidifier_setpoint_scale_get_enum_value_name((uint32_t)value); +- #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) +- jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_SCALE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ nlohmann::json bitmap_values = UserCredentialSupportedCredentialRules.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; + + + std::string payload_str; +@@ -95039,12 +95408,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_p + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointScale", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportedCredentialRules", e.what()); + return SL_STATUS_OK; + } + ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointScale"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportedCredentialRules"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95064,14 +95435,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_p + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_rules_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/DehumidifierSetpointScale"; ++ + "/UserCredential/Attributes/SupportedCredentialRules"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95087,9 +95458,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_u + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_types_publish( + const char *base_topic, +- uint8_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95097,11 +95468,8 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precisi + + // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,14,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,14,value); +- }else{ +- jsn["value"] = value; +- } ++ nlohmann::json bitmap_values = UserCredentialSupportedCredentialTypes.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; + + + std::string payload_str; +@@ -95109,12 +95477,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precisi + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportedCredentialTypes", e.what()); + return SL_STATUS_OK; + } + ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportedCredentialTypes"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95134,14 +95504,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precisi + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_credential_types_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision"; ++ + "/UserCredential/Attributes/SupportedCredentialTypes"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95157,9 +95527,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precisi + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_types_publish( + const char *base_topic, +- int32_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95167,11 +95537,8 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_publish( + + // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,15,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,15,value); +- }else{ +- jsn["value"] = value; +- } ++ nlohmann::json bitmap_values = UserCredentialSupportedUserTypes.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; + + + std::string payload_str; +@@ -95179,12 +95546,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_publish( + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointMin", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportedUserTypes", e.what()); + return SL_STATUS_OK; + } + ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointMin"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportedUserTypes"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95204,14 +95573,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_publish( + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_supported_user_types_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/AutoSetpointMin"; ++ + "/UserCredential/Attributes/SupportedUserTypes"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95227,9 +95596,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_unretain( + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_support_credential_checksum_publish( + const char *base_topic, +- int32_t value, ++ bool value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95237,8 +95606,8 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_publish( + + // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,16,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,16,value); ++ if (true == uic_dotdot_has_attribute_value_a_name(64776,4,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64776,4,value); + }else{ + jsn["value"] = value; + } +@@ -95249,12 +95618,12 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_publish( + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointMax", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportCredentialChecksum", e.what()); + return SL_STATUS_OK; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointMax"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportCredentialChecksum"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95274,14 +95643,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_publish( + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_support_credential_checksum_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/AutoSetpointMax"; ++ + "/UserCredential/Attributes/SupportCredentialChecksum"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95297,9 +95666,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_unretain( + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_publish( + const char *base_topic, +- int32_t value, ++ bool value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95307,8 +95676,8 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_publish( + + // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,17,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,17,value); ++ if (true == uic_dotdot_has_attribute_value_a_name(64776,5,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64776,5,value); + }else{ + jsn["value"] = value; + } +@@ -95319,12 +95688,12 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_publish( + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpoint", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportAdminPinCode", e.what()); + return SL_STATUS_OK; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpoint"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportAdminPinCode"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95344,14 +95713,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_publish( + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/AutoSetpoint"; ++ + "/UserCredential/Attributes/SupportAdminPinCode"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95367,9 +95736,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_unretain( + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_publish( + const char *base_topic, +- ScaleType value, ++ bool value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95377,14 +95746,11 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_publish( + + // This is a single value + +- #ifdef UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_SCALE_ENUM_NAME_AVAILABLE +- jsn["value"] = unify_humidity_control_auto_setpoint_scale_get_enum_value_name((uint32_t)value); +- #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) +- jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); +- #else +- sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_SCALE. Using number instead."); +- jsn["value"] = static_cast(value); +- #endif ++ if (true == uic_dotdot_has_attribute_value_a_name(64776,6,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64776,6,value); ++ }else{ ++ jsn["value"] = value; ++ } + + + std::string payload_str; +@@ -95392,12 +95758,12 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_publish( + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointScale", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/SupportAdminPinCodeDeactivation", e.what()); + return SL_STATUS_OK; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointScale"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/SupportAdminPinCodeDeactivation"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95417,14 +95783,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_publish( + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/AutoSetpointScale"; ++ + "/UserCredential/Attributes/SupportAdminPinCodeDeactivation"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95440,9 +95806,9 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( + } + // clang-format off + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( ++sl_status_t uic_mqtt_dotdot_user_credential_admin_pin_code_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -95450,11 +95816,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publi + + // This is a single value + +- if (true == uic_dotdot_has_attribute_value_a_name(64928,19,value)) { +- jsn["value"] = uic_dotdot_get_attribute_value_name(64928,19,value); +- }else{ +- jsn["value"] = value; +- } ++ jsn["value"] = std::string(value); + + + std::string payload_str; +@@ -95462,12 +95824,12 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publi + // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters + payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); + } catch (const nlohmann::json::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointPrecision", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential/Attributes/AdminPinCode", e.what()); + return SL_STATUS_OK; + } + + +- std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointPrecision"; ++ std::string topic = std::string(base_topic) + "/UserCredential/Attributes/AdminPinCode"; + if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) + { + std::string topic_desired = topic + "/Desired"; +@@ -95487,14 +95849,14 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publi + return SL_STATUS_OK; + } + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_unretain( ++sl_status_t uic_mqtt_dotdot_user_credential_admin_pin_code_unretain( + const char *base_topic, + uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on + std::string topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/AutoSetpointPrecision"; ++ + "/UserCredential/Attributes/AdminPinCode"; + + if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) + || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { +@@ -95511,5924 +95873,4386 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_unret + // clang-format off + + +-sl_status_t uic_mqtt_dotdot_unify_humidity_control_init() ++sl_status_t uic_mqtt_dotdot_user_credential_init() + { + std::string base_topic = "ucl/by-unid/+/+/"; + + std::string subscription_topic; +- if(!uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_WriteAttributes); ++ if(!uic_mqtt_dotdot_user_credential_write_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_WriteAttributes); + } + +- if(!uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/Commands/ForceReadAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_force_read_attributes); ++ if(!uic_mqtt_dotdot_user_credential_force_read_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/ForceReadAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_force_read_attributes); + } +- if (!uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/Commands/ModeSet"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_mode_set); ++ if (!uic_mqtt_dotdot_user_credential_add_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/AddUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_add_user); + } +- if (!uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/GeneratedCommands/ModeSet"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set); ++ if (!uic_mqtt_dotdot_user_credential_generated_add_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/AddUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_add_user); + } +- if (!uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/Commands/SetpointSet"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set); ++ if (!uic_mqtt_dotdot_user_credential_modify_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/ModifyUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_modify_user); + } +- if (!uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.empty()) { +- subscription_topic = base_topic + "UnifyHumidityControl/GeneratedCommands/SetpointSet"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set); ++ if (!uic_mqtt_dotdot_user_credential_generated_modify_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/ModifyUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_modify_user); + } +- +- // Init the attributes for that cluster +- uic_mqtt_dotdot_unify_humidity_control_attributes_init(); +- +- uic_mqtt_dotdot_by_group_unify_humidity_control_init(); +- +- return SL_STATUS_OK; +-} +- +- +-sl_status_t uic_mqtt_dotdot_init() { +- +- sl_status_t status_flag = SL_STATUS_OK; +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_basic_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_user); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_power_configuration_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_user); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_device_temperature_configuration_init(); ++ if (!uic_mqtt_dotdot_user_credential_add_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/AddCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_add_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_identify_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_add_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/AddCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_add_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_groups_init(); ++ if (!uic_mqtt_dotdot_user_credential_modify_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/ModifyCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_modify_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_scenes_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_modify_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/ModifyCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_modify_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_on_off_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_level_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_credential_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_credential); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_alarms_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_all_users_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteAllUsers"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_all_users); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_time_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_all_users_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteAllUsers"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_all_users); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_poll_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_all_credentials_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteAllCredentials"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_all_credentials); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_shade_configuration_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteAllCredentials"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_door_lock_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteAllCredentialsByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_all_credentials_by_type); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_window_covering_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_by_type_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteAllCredentialsByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_by_type); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_barrier_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteAllCredentialsForUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_pump_configuration_and_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteAllCredentialsForUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_for_user); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_thermostat_init(); ++ if (!uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeleteAllCredentialsForUserByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user_by_type); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_fan_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_delete_all_credentials_for_user_by_type_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_for_user_by_type); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_dehumidification_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/CredentialLearnStartAdd"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_credential_learn_start_add); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_thermostat_user_interface_configuration_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_credential_learn_start_add_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/CredentialLearnStartAdd"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_add); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_color_control_init(); ++ if (!uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/CredentialLearnStartModify"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_credential_learn_start_modify); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_ballast_configuration_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_credential_learn_start_modify_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/CredentialLearnStartModify"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_modify); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_illuminance_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_credential_learn_stop_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/CredentialLearnStop"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_credential_learn_stop); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_illuminance_level_sensing_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_credential_learn_stop_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/CredentialLearnStop"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_credential_learn_stop); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_temperature_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_credential_association_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/CredentialAssociation"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_credential_association); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_pressure_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_credential_association_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/CredentialAssociation"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_credential_association); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_flow_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_get_user_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/GetUserChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_get_user_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_relativity_humidity_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_get_user_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/GetUserChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_get_user_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_occupancy_sensing_init(); ++ if (!uic_mqtt_dotdot_user_credential_get_credential_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/GetCredentialChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_get_credential_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_soil_moisture_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_get_credential_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/GetCredentialChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_get_credential_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_ph_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/GetAllUsersChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_get_all_users_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_electrical_conductivity_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_get_all_users_checksum_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/GetAllUsersChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_get_all_users_checksum); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_wind_speed_measurement_init(); ++ if (!uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/SetAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_set_admin_pin_code); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_carbon_monoxide_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_set_admin_pin_code_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/SetAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_set_admin_pin_code); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_carbon_dioxide_init(); ++ if (!uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/Commands/DeactivateAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_user_credential_deactivate_admin_pin_code); + } +- +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_pm25_init(); ++ if (!uic_mqtt_dotdot_user_credential_generated_deactivate_admin_pin_code_callback.empty()) { ++ subscription_topic = base_topic + "UserCredential/GeneratedCommands/DeactivateAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_user_credential_deactivate_admin_pin_code); + } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_ias_zone_init(); +- } ++ // Init the attributes for that cluster ++ uic_mqtt_dotdot_user_credential_attributes_init(); + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_iaswd_init(); +- } ++ uic_mqtt_dotdot_by_group_user_credential_init(); + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_metering_init(); +- } ++ return SL_STATUS_OK; ++} + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_electrical_measurement_init(); +- } ++// Callbacks pointers ++static std::set uic_mqtt_dotdot_protocol_controller_network_management_write_callback; ++static std::set uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback; ++static std::set uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback; ++static std::set uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback; + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_diagnostics_init(); ++// Callbacks setters ++void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_set(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_protocol_controller_network_management_write_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_unset(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_write_callback.erase(callback); ++} ++void uic_mqtt_dotdot_protocol_controller_network_management_write_callback_clear() ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_write_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_protocol_controller_network_management_write_callback() ++{ ++ return uic_mqtt_dotdot_protocol_controller_network_management_write_callback; ++} + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_protocol_controller_rf_telemetry_init(); ++void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_set(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_unset(const uic_mqtt_dotdot_protocol_controller_network_management_write_callback_t callback) ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.erase(callback); ++} ++void uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback_clear() ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.clear(); ++} + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_state_init(); ++void uic_mqtt_dotdot_set_protocol_controller_network_management_write_attributes_callback( ++ const uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_unset_protocol_controller_network_management_write_attributes_callback( ++ const uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t callback) ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.erase(callback); ++} ++void uic_mqtt_dotdot_clear_protocol_controller_network_management_write_attributes_callbacks() ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback() ++{ ++ return uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback; ++} + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_binding_init(); ++void uic_mqtt_dotdot_set_protocol_controller_network_management_force_read_attributes_callback( ++ const uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.insert(callback); + } ++} ++void uic_mqtt_dotdot_unset_protocol_controller_network_management_force_read_attributes_callback( ++ const uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t callback) ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.erase(callback); ++} ++void uic_mqtt_dotdot_clear_protocol_controller_network_management_force_read_attributes_callbacks() ++{ ++ uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.clear(); ++} + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_system_metrics_init(); +- } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_application_monitoring_init(); ++// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/Commands/Write ++void uic_mqtt_dotdot_on_protocol_controller_network_management_write( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_protocol_controller_network_management_write_callback.empty())) { ++ return; + } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_name_and_location_init(); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID from topic %s. Ignoring", ++ topic); ++ return; + } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_configuration_parameters_init(); +- } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_protocol_controller_network_management_init(); +- } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_descriptor_init(); +- } ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_unify_fan_control_init(); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "Write"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", ""); ++ return; + } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_unify_thermostat_init(); +- } + +- if (status_flag == SL_STATUS_OK) { +- status_flag = uic_mqtt_dotdot_unify_humidity_control_init(); +- } + ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); ++ } + +- return status_flag; + } + +-// Publish all supported dotdot cluster commands per each endpoints. +-void uic_mqtt_dotdot_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/GeneratedCommands/Write ++static void uic_mqtt_dotdot_on_generated_protocol_controller_network_management_write( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- uic_mqtt_dotdot_basic_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_power_configuration_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_device_temperature_configuration_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_identify_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_groups_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_scenes_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_on_off_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_level_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_alarms_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_time_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_poll_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_shade_configuration_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_door_lock_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_window_covering_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_barrier_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_thermostat_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_fan_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_dehumidification_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_color_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ballast_configuration_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_illuminance_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_temperature_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pressure_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_flow_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_relativity_humidity_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_soil_moisture_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ph_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_wind_speed_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_carbon_monoxide_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_carbon_dioxide_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pm25_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ias_zone_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_iaswd_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_metering_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_electrical_measurement_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_diagnostics_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_supported_commands(unid, 0); +- uic_mqtt_dotdot_state_publish_supported_commands(unid, 0); +- uic_mqtt_dotdot_binding_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_system_metrics_publish_supported_commands(unid, 0); +- uic_mqtt_dotdot_application_monitoring_publish_supported_commands(unid, 0); +- uic_mqtt_dotdot_name_and_location_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_configuration_parameters_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_commands(unid, 0); +- uic_mqtt_dotdot_descriptor_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_fan_control_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_thermostat_publish_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_humidity_control_publish_supported_commands(unid, endpoint_id); +-} ++ if (message_length == 0 || (uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.empty())) { ++ return; ++ } + +-void uic_mqtt_dotdot_publish_empty_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uic_mqtt_dotdot_basic_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_power_configuration_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_device_temperature_configuration_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_identify_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_groups_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_scenes_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_on_off_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_level_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_alarms_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_time_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_poll_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_shade_configuration_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_door_lock_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_window_covering_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pump_configuration_and_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_thermostat_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_fan_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_dehumidification_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_color_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_illuminance_level_sensing_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_temperature_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_relativity_humidity_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_wind_speed_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_carbon_monoxide_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_carbon_dioxide_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_pm25_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_ias_zone_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_iaswd_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_metering_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_diagnostics_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_empty_supported_commands(unid); +- uic_mqtt_dotdot_state_publish_empty_supported_commands(unid); +- uic_mqtt_dotdot_binding_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_system_metrics_publish_empty_supported_commands(unid); +- uic_mqtt_dotdot_application_monitoring_publish_empty_supported_commands(unid); +- uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_protocol_controller_network_management_publish_empty_supported_commands(unid); +- uic_mqtt_dotdot_descriptor_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_fan_control_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_thermostat_publish_empty_supported_commands(unid, endpoint_id); +- uic_mqtt_dotdot_unify_humidity_control_publish_empty_supported_commands(unid, endpoint_id); +-} ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +-// Publishing Cluster Revision for Basic Cluster +-void uic_mqtt_dotdot_basic_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/Basic/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for Basic Cluster +-void uic_mqtt_dotdot_basic_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Basic/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} + +-static inline bool uic_mqtt_dotdot_basic_reset_to_factory_defaults_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_basic_reset_to_factory_defaults_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "Write"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "Write", ""); ++ return; + } + +- return false; +-} + +-static inline bool uic_mqtt_dotdot_basic_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_basic_write_attributes_callback) { +- uic_mqtt_dotdot_basic_state_t basic_new_state = {}; +- uic_mqtt_dotdot_basic_updated_state_t basic_new_updated_state = {}; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- basic_new_state, +- basic_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_basic_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_basic_force_read_attributes_callback) { +- uic_mqtt_dotdot_basic_updated_state_t basic_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- basic_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } +- return false; + } + +-// Publishing Supported Commands for Basic Cluster +-void uic_mqtt_dotdot_basic_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_basic_reset_to_factory_defaults_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ResetToFactoryDefaults")"; ++// Callback function for incoming publications on ucl/by-unid/+/+/ProtocolController-NetworkManagement/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_protocol_controller_network_management_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.empty()) { ++ return; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_basic_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ if (message_length == 0) { ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_basic_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic_no_endpoint(topic,unid)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Basic/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Basic/Attributes"; ++ uic_mqtt_dotdot_protocol_controller_network_management_state_t new_state = {}; ++ uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t new_updated_state = {}; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } +-} + +-// Publishing empty/no Supported Commands for Basic Cluster +-void uic_mqtt_dotdot_basic_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Basic/SupportedCommands"; ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uic_mqtt_dotdot_parse_protocol_controller_network_management_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "ProtocolController-NetworkManagement", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController-NetworkManagement", "WriteAttributes", ""); ++ return; + } +-} + +-// Publishing Cluster Revision for PowerConfiguration Cluster +-void uic_mqtt_dotdot_power_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/PowerConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); ++ } + +-// Unretain Cluster Revision for PowerConfiguration Cluster +-void uic_mqtt_dotdot_power_configuration_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/PowerConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_power_configuration_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++static void uic_mqtt_dotdot_on_protocol_controller_network_management_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- for (const auto& callback: uic_mqtt_dotdot_power_configuration_write_attributes_callback) { +- uic_mqtt_dotdot_power_configuration_state_t power_configuration_new_state = {}; +- uic_mqtt_dotdot_power_configuration_updated_state_t power_configuration_new_updated_state = {}; ++ uint8_t endpoint = 0; ++ std::string unid; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- power_configuration_new_state, +- power_configuration_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ if ((message_length == 0) || (uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.empty())) { ++ return; + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_power_configuration_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_power_configuration_force_read_attributes_callback) { +- uic_mqtt_dotdot_power_configuration_updated_state_t power_configuration_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- power_configuration_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- return false; +-} + +-// Publishing Supported Commands for PowerConfiguration Cluster +-void uic_mqtt_dotdot_power_configuration_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ try { ++ uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t force_update = {0}; ++ bool trigger_handler = false; + +- // check if there is callback for each command ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_power_configuration_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.network_management_state = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"NetworkManagementState", &force_update.network_management_state }, ++ }; + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_power_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PowerConfiguration/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PowerConfiguration/Attributes"; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } + } ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "ProtocolController-NetworkManagement/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; + } + } + +-// Publishing empty/no Supported Commands for PowerConfiguration Cluster +-void uic_mqtt_dotdot_power_configuration_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_network_management_state_publish( ++ const char *base_topic, ++ NetworkManagementState value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PowerConfiguration/SupportedCommands"; ++ nlohmann::json jsn; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ // This is a single value ++ ++ nlohmann::json json_object = nlohmann::json::object(); ++ json_object["State"] = value.State; ++ json_object["SupportedStateList"] = value.SupportedStateList; ++ json_object["StateParameters"] = value.StateParameters; ++ json_object["RequestedStateParameters"] = value.RequestedStateParameters; ++ jsn["value"]= json_object; ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "ProtocolController/NetworkManagement/Attributes/NetworkManagementState", e.what()); ++ return SL_STATUS_OK; + } +-} + +-// Publishing Cluster Revision for DeviceTemperatureConfiguration Cluster +-void uic_mqtt_dotdot_device_temperature_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/DeviceTemperatureConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ ++ std::string topic = std::string(base_topic) + "/ProtocolController/NetworkManagement/Attributes/NetworkManagementState"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } + +-// Unretain Cluster Revision for DeviceTemperatureConfiguration Cluster +-void uic_mqtt_dotdot_device_temperature_configuration_unretain_cluster_revision(const char* base_topic) ++sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_network_management_state_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on +- std::string cluster_topic ++ std::string topic + = std::string(base_topic) +- + "/DeviceTemperatureConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ + "/ProtocolController/NetworkManagement/Attributes/NetworkManagementState"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } ++// clang-format off + + +-static inline bool uic_mqtt_dotdot_device_temperature_configuration_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_init() + { +- for (const auto& callback: uic_mqtt_dotdot_device_temperature_configuration_write_attributes_callback) { +- uic_mqtt_dotdot_device_temperature_configuration_state_t device_temperature_configuration_new_state = {}; +- uic_mqtt_dotdot_device_temperature_configuration_updated_state_t device_temperature_configuration_new_updated_state = {}; ++ std::string base_topic = "ucl/by-unid/+/"; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- device_temperature_configuration_new_state, +- device_temperature_configuration_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string subscription_topic; ++ if(!uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback.empty()) { ++ subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_WriteAttributes); + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_callback) { +- uic_mqtt_dotdot_device_temperature_configuration_updated_state_t device_temperature_configuration_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- device_temperature_configuration_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ if(!uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback.empty()) { ++ subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/ForceReadAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_force_read_attributes); ++ } ++ if (!uic_mqtt_dotdot_protocol_controller_network_management_write_callback.empty()) { ++ subscription_topic = base_topic + "ProtocolController/NetworkManagement/Commands/Write"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_protocol_controller_network_management_write); ++ } ++ if (!uic_mqtt_dotdot_protocol_controller_network_management_generated_write_callback.empty()) { ++ subscription_topic = base_topic + "ProtocolController/NetworkManagement/GeneratedCommands/Write"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_protocol_controller_network_management_write); + } +- return false; +-} + +-// Publishing Supported Commands for DeviceTemperatureConfiguration Cluster +-void uic_mqtt_dotdot_device_temperature_configuration_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ // Init the attributes for that cluster ++ uic_mqtt_dotdot_protocol_controller_network_management_attributes_init(); + +- // check if there is callback for each command + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_device_temperature_configuration_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } ++ return SL_STATUS_OK; ++} + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } ++// Callbacks pointers ++static std::set uic_mqtt_dotdot_descriptor_write_attributes_callback; ++static std::set uic_mqtt_dotdot_descriptor_force_read_attributes_callback; + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DeviceTemperatureConfiguration/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/DeviceTemperatureConfiguration/Attributes"; ++// Callbacks setters + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++void uic_mqtt_dotdot_set_descriptor_write_attributes_callback( ++ const uic_mqtt_dotdot_descriptor_write_attributes_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_descriptor_write_attributes_callback.insert(callback); + } + } +- +-// Publishing empty/no Supported Commands for DeviceTemperatureConfiguration Cluster +-void uic_mqtt_dotdot_device_temperature_configuration_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_descriptor_write_attributes_callback( ++ const uic_mqtt_dotdot_descriptor_write_attributes_callback_t callback) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DeviceTemperatureConfiguration/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ uic_mqtt_dotdot_descriptor_write_attributes_callback.erase(callback); + } +- +-// Publishing Cluster Revision for Identify Cluster +-void uic_mqtt_dotdot_identify_publish_cluster_revision(const char* base_topic, uint16_t value) ++void uic_mqtt_dotdot_clear_descriptor_write_attributes_callbacks() + { +- std::string cluster_topic = std::string(base_topic) + "/Identify/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ uic_mqtt_dotdot_descriptor_write_attributes_callback.clear(); + } +- +-// Unretain Cluster Revision for Identify Cluster +-void uic_mqtt_dotdot_identify_unretain_cluster_revision(const char* base_topic) ++std::set& get_uic_mqtt_dotdot_descriptor_write_attributes_callback() + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Identify/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return uic_mqtt_dotdot_descriptor_write_attributes_callback; + } + +-static inline bool uic_mqtt_dotdot_identify_identify_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_set_descriptor_force_read_attributes_callback( ++ const uic_mqtt_dotdot_descriptor_force_read_attributes_callback_t callback) + { +- uint16_t identify_time_value; +- memset(&identify_time_value, 0x00, sizeof(identify_time_value)); +- for (const auto& callback: uic_mqtt_dotdot_identify_identify_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- identify_time_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_descriptor_force_read_attributes_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_identify_identify_query_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_descriptor_force_read_attributes_callback( ++ const uic_mqtt_dotdot_descriptor_force_read_attributes_callback_t callback) + { +- uint16_t timeout_value; +- memset(&timeout_value, 0x00, sizeof(timeout_value)); +- for (const auto& callback: uic_mqtt_dotdot_identify_identify_query_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- timeout_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_descriptor_force_read_attributes_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_identify_identify_query_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_clear_descriptor_force_read_attributes_callbacks() + { +- for (const auto& callback: uic_mqtt_dotdot_identify_identify_query_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_descriptor_force_read_attributes_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_identify_trigger_effect_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/Descriptor/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_descriptor_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- TriggerEffectEffectIdentifier effect_identifier_value; +- memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- TriggerEffectEffectVariant effect_variant_value; +- memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); +- for (const auto& callback: uic_mqtt_dotdot_identify_trigger_effect_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- effect_identifier_value, +- +- effect_variant_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (uic_mqtt_dotdot_descriptor_write_attributes_callback.empty()) { ++ return; + } + +- return false; +-} ++ if (message_length == 0) { ++ return; ++ } + +-static inline bool uic_mqtt_dotdot_identify_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_identify_write_attributes_callback) { +- uic_mqtt_dotdot_identify_state_t identify_new_state = {}; +- uic_mqtt_dotdot_identify_updated_state_t identify_new_updated_state = {}; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- identify_new_state, +- identify_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ uic_mqtt_dotdot_descriptor_state_t new_state = {}; ++ uic_mqtt_dotdot_descriptor_updated_state_t new_updated_state = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_descriptor_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "Descriptor", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", ""); ++ return; + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_identify_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_identify_force_read_attributes_callback) { +- uic_mqtt_dotdot_identify_updated_state_t identify_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- identify_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ for (const auto& callback: uic_mqtt_dotdot_descriptor_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); + } +- return false; ++ + } + +-// Publishing Supported Commands for Identify Cluster +-void uic_mqtt_dotdot_identify_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++static void uic_mqtt_dotdot_on_descriptor_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ uint8_t endpoint = 0; ++ std::string unid; + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_identify_identify_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Identify")"; +- } +- if (uic_mqtt_dotdot_identify_identify_query_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("IdentifyQueryResponse")"; +- } +- if (uic_mqtt_dotdot_identify_identify_query_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("IdentifyQuery")"; +- } +- if (uic_mqtt_dotdot_identify_trigger_effect_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("TriggerEffect")"; ++ if ((message_length == 0) || (uic_mqtt_dotdot_descriptor_force_read_attributes_callback.empty())) { ++ return; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_identify_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_identify_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } ++ try { ++ uic_mqtt_dotdot_descriptor_updated_state_t force_update = {0}; ++ bool trigger_handler = false; + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Identify/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Identify/Attributes"; ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.device_type_list = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"DeviceTypeList", &force_update.device_type_list }, ++ }; ++ ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } ++ } ++ ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_descriptor_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } + } ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "Descriptor/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; + } + } + +-// Publishing empty/no Supported Commands for Identify Cluster +-void uic_mqtt_dotdot_identify_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_descriptor_device_type_list_publish( ++ const char *base_topic, ++ size_t value_count, ++ const DeviceTypeStruct* value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Identify/SupportedCommands"; ++ nlohmann::json jsn; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ // This is a variable size array of the same known type. ++ // Create an array under the value {"value":[]} ++ jsn["value"] = nlohmann::json::array(); ++ ++ for (size_t i = 0; i uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback; ++static std::set uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback; ++static std::set uic_mqtt_dotdot_unify_fan_control_turn_off_callback; ++static std::set uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback; ++static std::set uic_mqtt_dotdot_unify_fan_control_write_attributes_callback; ++static std::set uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback; ++ ++// Callbacks setters ++void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_set(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) + { +- uint16_t group_id_value; +- memset(&group_id_value, 0x00, sizeof(group_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_view_group_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- group_id_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_groups_view_group_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_unset(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) + { +- uint8_t status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; +- memset(&group_id_value, 0x00, sizeof(group_id_value)); +- const char* group_name_value; +- memset(&group_name_value, 0x00, sizeof(group_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_view_group_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- group_id_value, +- +- group_name_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_groups_get_group_membership_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_clear() + { +- for (const auto& callback: uic_mqtt_dotdot_groups_get_group_membership_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- 0, nullptr +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_groups_get_group_membership_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++std::set& get_uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback() + { +- uint8_t capacity_value; +- memset(&capacity_value, 0x00, sizeof(capacity_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_get_group_membership_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- capacity_value, +- +- 0, nullptr +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ return uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback; + } +-static inline bool uic_mqtt_dotdot_groups_remove_group_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_set(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) + { +- uint16_t group_id_value; +- memset(&group_id_value, 0x00, sizeof(group_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- group_id_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_groups_remove_group_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_unset(const uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_t callback) + { +- uint8_t status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; +- memset(&group_id_value, 0x00, sizeof(group_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- group_id_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_groups_remove_all_groups_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback_clear() + { +- for (const auto& callback: uic_mqtt_dotdot_groups_remove_all_groups_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_groups_add_group_if_identifying_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_set(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) + { +- uint16_t group_id_value; +- memset(&group_id_value, 0x00, sizeof(group_id_value)); +- const char* group_name_value; +- memset(&group_name_value, 0x00, sizeof(group_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- group_id_value, +- +- group_name_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_turn_off_callback.insert(callback); + } +- +- return false; + } +- +-static inline bool uic_mqtt_dotdot_groups_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_unset(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_groups_write_attributes_callback) { +- uic_mqtt_dotdot_groups_state_t groups_new_state = {}; +- uic_mqtt_dotdot_groups_updated_state_t groups_new_updated_state = {}; ++ uic_mqtt_dotdot_unify_fan_control_turn_off_callback.erase(callback); ++} ++void uic_mqtt_dotdot_unify_fan_control_turn_off_callback_clear() ++{ ++ uic_mqtt_dotdot_unify_fan_control_turn_off_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_unify_fan_control_turn_off_callback() ++{ ++ return uic_mqtt_dotdot_unify_fan_control_turn_off_callback; ++} + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- groups_new_state, +- groups_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_set(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.insert(callback); + } +- return false; ++} ++void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_unset(const uic_mqtt_dotdot_unify_fan_control_turn_off_callback_t callback) ++{ ++ uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.erase(callback); ++} ++void uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback_clear() ++{ ++ uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.clear(); + } + +-static inline bool uic_mqtt_dotdot_groups_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_set_unify_fan_control_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_fan_control_write_attributes_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_groups_force_read_attributes_callback) { +- uic_mqtt_dotdot_groups_updated_state_t groups_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- groups_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.insert(callback); + } +- return false; + } +- +-// Publishing Supported Commands for Groups Cluster +-void uic_mqtt_dotdot_groups_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_unify_fan_control_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_fan_control_write_attributes_callback_t callback) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.erase(callback); ++} ++void uic_mqtt_dotdot_clear_unify_fan_control_write_attributes_callbacks() ++{ ++ uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_unify_fan_control_write_attributes_callback() ++{ ++ return uic_mqtt_dotdot_unify_fan_control_write_attributes_callback; ++} + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_groups_add_group_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("AddGroup")"; ++void uic_mqtt_dotdot_set_unify_fan_control_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.insert(callback); + } +- if (uic_mqtt_dotdot_groups_add_group_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("AddGroupResponse")"; ++} ++void uic_mqtt_dotdot_unset_unify_fan_control_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback_t callback) ++{ ++ uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.erase(callback); ++} ++void uic_mqtt_dotdot_clear_unify_fan_control_force_read_attributes_callbacks() ++{ ++ uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.clear(); ++} ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/SetFanMode ++void uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.empty())) { ++ return; + } +- if (uic_mqtt_dotdot_groups_view_group_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ViewGroup")"; ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- if (uic_mqtt_dotdot_groups_view_group_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ViewGroupResponse")"; ++ ++ ZWaveFanModeEnum fan_mode = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ jsn, ++ fan_mode ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ return; + } +- if (uic_mqtt_dotdot_groups_get_group_membership_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetGroupMembership")"; ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ fan_mode ++ ++ ); + } +- if (uic_mqtt_dotdot_groups_get_group_membership_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetGroupMembershipResponse")"; ++ ++} ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/GeneratedCommands/SetFanMode ++static void uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.empty())) { ++ return; + } +- if (uic_mqtt_dotdot_groups_remove_group_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveGroup")"; ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- if (uic_mqtt_dotdot_groups_remove_group_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveGroupResponse")"; ++ ++ ZWaveFanModeEnum fan_mode = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ jsn, ++ fan_mode ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ return; + } +- if (uic_mqtt_dotdot_groups_remove_all_groups_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveAllGroups")"; ++ ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ fan_mode ++ ++ ); + } +- if (uic_mqtt_dotdot_groups_add_group_if_identifying_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("AddGroupIfIdentifying")"; ++} ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/TurnOff ++void uic_mqtt_dotdot_on_unify_fan_control_turn_off( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_turn_off_callback.empty())) { ++ return; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_groups_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_groups_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ return; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Groups/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Groups/Attributes"; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_turn_off_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); + } ++ + } + +-// Publishing empty/no Supported Commands for Groups Cluster +-void uic_mqtt_dotdot_groups_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/GeneratedCommands/TurnOff ++static void uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Groups/SupportedCommands"; ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.empty())) { ++ return; ++ } + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +-} + +-// Publishing Cluster Revision for Scenes Cluster +-void uic_mqtt_dotdot_scenes_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/Scenes/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for Scenes Cluster +-void uic_mqtt_dotdot_scenes_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Scenes/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} + +-static inline bool uic_mqtt_dotdot_scenes_add_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; +- memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- uint8_t transition_time100ms_value; +- memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value, +- +- transition_time_value, +- +- scene_name_value, +- +- 0, nullptr, ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- transition_time100ms_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ return; + } + +- return false; ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL ++ ); ++ } + } +-static inline bool uic_mqtt_dotdot_scenes_add_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyFanControl/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_unify_fan_control_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.empty()) { ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_view_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (message_length == 0) { ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_view_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; +- memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value, +- +- transition_time_value, +- +- scene_name_value, +- +- 0, nullptr +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_remove_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ uic_mqtt_dotdot_unify_fan_control_state_t new_state = {}; ++ uic_mqtt_dotdot_unify_fan_control_updated_state_t new_updated_state = {}; + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_remove_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ uic_mqtt_dotdot_parse_unify_fan_control_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "WriteAttributes", ""); ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_store_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); + } + +- return false; + } +-static inline bool uic_mqtt_dotdot_scenes_store_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_recall_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++static void uic_mqtt_dotdot_on_unify_fan_control_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_recall_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value, +- +- transition_time_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ uint8_t endpoint = 0; ++ std::string unid; ++ ++ if ((message_length == 0) || (uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.empty())) { ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t capacity_value; +- memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- capacity_value, +- +- groupid_value, +- +- 0, nullptr ++ try { ++ uic_mqtt_dotdot_unify_fan_control_updated_state_t force_update = {0}; ++ bool trigger_handler = false; + +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; +- memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value, +- +- transition_time_value, +- +- scene_name_value, +- +- 0, nullptr ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.z_wave_fan_mode = true; ++ force_update.z_wave_supported_fan_mode = true; ++ force_update.z_wave_fan_state = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"ZWaveFanMode", &force_update.z_wave_fan_mode }, ++ {"ZWaveSupportedFanMode", &force_update.z_wave_supported_fan_mode }, ++ {"ZWaveFanState", &force_update.z_wave_fan_state }, ++ }; + +- ) == SL_STATUS_OK) { +- return true; ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } + } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } + } ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "UnifyFanControl/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- groupid_value, +- +- sceneid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_mode_publish( ++ const char *base_topic, ++ ZWaveFanModeEnum value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; +- memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; +- memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; +- memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- groupid_value, +- +- sceneid_value, +- +- transition_time_value, +- +- scene_name_value, +- +- 0, nullptr ++ nlohmann::json jsn; + +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // This is a single value + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_copy_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t mode_value; +- memset(&mode_value, 0x00, sizeof(mode_value)); +- uint16_t group_identifier_from_value; +- memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; +- memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint16_t group_identifier_to_value; +- memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- uint8_t scene_identifier_to_value; +- memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- mode_value, +- +- group_identifier_from_value, +- +- scene_identifier_from_value, +- +- group_identifier_to_value, +- +- scene_identifier_to_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ #ifdef UNIFY_FAN_CONTROL_Z_WAVE_FAN_MODE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_fan_control_z_wave_fan_mode_get_enum_value_name((uint32_t)value); ++ #elif defined(Z_WAVE_FAN_MODE_ENUM_ENUM_NAME_AVAILABLE) ++ jsn["value"] = z_wave_fan_mode_enum_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_FAN_CONTROL_Z_WAVE_FAN_MODE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif + +- return false; +-} +-static inline bool uic_mqtt_dotdot_scenes_copy_scene_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_identifier_from_value; +- memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; +- memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- group_identifier_from_value, +- +- scene_identifier_from_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveFanMode", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveFanMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } + +-static inline bool uic_mqtt_dotdot_scenes_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- for (const auto& callback: uic_mqtt_dotdot_scenes_write_attributes_callback) { +- uic_mqtt_dotdot_scenes_state_t scenes_new_state = {}; +- uic_mqtt_dotdot_scenes_updated_state_t scenes_new_updated_state = {}; ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyFanControl/Attributes/ZWaveFanMode"; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- scenes_new_state, +- scenes_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); + } +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } ++// clang-format off + +-static inline bool uic_mqtt_dotdot_scenes_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_scenes_force_read_attributes_callback) { +- uic_mqtt_dotdot_scenes_updated_state_t scenes_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- scenes_force_update +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} +- +-// Publishing Supported Commands for Scenes Cluster +-void uic_mqtt_dotdot_scenes_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_supported_fan_mode_publish( ++ const char *base_topic, ++ uint16_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ nlohmann::json jsn; + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_scenes_add_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("AddScene")"; +- } +- if (uic_mqtt_dotdot_scenes_add_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("AddSceneResponse")"; +- } +- if (uic_mqtt_dotdot_scenes_view_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ViewScene")"; +- } +- if (uic_mqtt_dotdot_scenes_view_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ViewSceneResponse")"; +- } +- if (uic_mqtt_dotdot_scenes_remove_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveScene")"; ++ // This is a single value ++ ++ nlohmann::json bitmap_values = UnifyFanControlZWaveSupportedFanMode.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveSupportedFanMode", e.what()); ++ return SL_STATUS_OK; + } +- if (uic_mqtt_dotdot_scenes_remove_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveSceneResponse")"; ++ ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); ++ ++ std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveSupportedFanMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- if (uic_mqtt_dotdot_scenes_remove_all_scenes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveAllScenes")"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- if (uic_mqtt_dotdot_scenes_remove_all_scenes_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RemoveAllScenesResponse")"; ++ return SL_STATUS_OK; ++} ++ ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_supported_fan_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++{ ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyFanControl/Attributes/ZWaveSupportedFanMode"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); + } +- if (uic_mqtt_dotdot_scenes_store_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("StoreScene")"; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); + } +- if (uic_mqtt_dotdot_scenes_store_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("StoreSceneResponse")"; ++ return SL_STATUS_OK; ++} ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_state_publish( ++ const char *base_topic, ++ ZWaveFanStateEnum value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) ++{ ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_FAN_CONTROL_Z_WAVE_FAN_STATE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_fan_control_z_wave_fan_state_get_enum_value_name((uint32_t)value); ++ #elif defined(Z_WAVE_FAN_STATE_ENUM_ENUM_NAME_AVAILABLE) ++ jsn["value"] = z_wave_fan_state_enum_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_FAN_CONTROL_Z_WAVE_FAN_STATE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl/Attributes/ZWaveFanState", e.what()); ++ return SL_STATUS_OK; + } +- if (uic_mqtt_dotdot_scenes_recall_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("RecallScene")"; ++ ++ ++ std::string topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ZWaveFanState"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- if (uic_mqtt_dotdot_scenes_get_scene_membership_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetSceneMembership")"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- if (uic_mqtt_dotdot_scenes_get_scene_membership_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetSceneMembershipResponse")"; ++ return SL_STATUS_OK; ++} ++ ++sl_status_t uic_mqtt_dotdot_unify_fan_control_z_wave_fan_state_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++{ ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyFanControl/Attributes/ZWaveFanState"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); + } +- if (uic_mqtt_dotdot_scenes_enhanced_add_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("EnhancedAddScene")"; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); + } +- if (uic_mqtt_dotdot_scenes_enhanced_add_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("EnhancedAddSceneResponse")"; ++ return SL_STATUS_OK; ++} ++// clang-format off ++ ++ ++sl_status_t uic_mqtt_dotdot_unify_fan_control_init() ++{ ++ std::string base_topic = "ucl/by-unid/+/+/"; ++ ++ std::string subscription_topic; ++ if(!uic_mqtt_dotdot_unify_fan_control_write_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_WriteAttributes); + } +- if (uic_mqtt_dotdot_scenes_enhanced_view_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("EnhancedViewScene")"; ++ ++ if(!uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/Commands/ForceReadAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_force_read_attributes); + } +- if (uic_mqtt_dotdot_scenes_enhanced_view_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("EnhancedViewSceneResponse")"; ++ if (!uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/Commands/SetFanMode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode); + } +- if (uic_mqtt_dotdot_scenes_copy_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("CopyScene")"; ++ if (!uic_mqtt_dotdot_unify_fan_control_generated_set_fan_mode_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/GeneratedCommands/SetFanMode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_fan_control_set_fan_mode); + } +- if (uic_mqtt_dotdot_scenes_copy_scene_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("CopySceneResponse")"; ++ if (!uic_mqtt_dotdot_unify_fan_control_turn_off_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/Commands/TurnOff"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_fan_control_turn_off); + } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_scenes_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ if (!uic_mqtt_dotdot_unify_fan_control_generated_turn_off_callback.empty()) { ++ subscription_topic = base_topic + "UnifyFanControl/GeneratedCommands/TurnOff"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_fan_control_turn_off); + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_scenes_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } ++ // Init the attributes for that cluster ++ uic_mqtt_dotdot_unify_fan_control_attributes_init(); + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Scenes/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Scenes/Attributes"; ++ uic_mqtt_dotdot_by_group_unify_fan_control_init(); + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return SL_STATUS_OK; + } + +-// Publishing empty/no Supported Commands for Scenes Cluster +-void uic_mqtt_dotdot_scenes_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Scenes/SupportedCommands"; ++// Callbacks pointers ++static std::set uic_mqtt_dotdot_unify_thermostat_write_attributes_callback; ++static std::set uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} ++// Callbacks setters + +-// Publishing Cluster Revision for OnOff Cluster +-void uic_mqtt_dotdot_on_off_publish_cluster_revision(const char* base_topic, uint16_t value) ++void uic_mqtt_dotdot_set_unify_thermostat_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_thermostat_write_attributes_callback_t callback) + { +- std::string cluster_topic = std::string(base_topic) + "/OnOff/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.insert(callback); ++ } + } +- +-// Unretain Cluster Revision for OnOff Cluster +-void uic_mqtt_dotdot_on_off_unretain_cluster_revision(const char* base_topic) ++void uic_mqtt_dotdot_unset_unify_thermostat_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_thermostat_write_attributes_callback_t callback) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/OnOff/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.erase(callback); + } +- +-static inline bool uic_mqtt_dotdot_on_off_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_clear_unify_thermostat_write_attributes_callbacks() + { +- for (const auto& callback: uic_mqtt_dotdot_on_off_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_on_off_on_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++std::set& get_uic_mqtt_dotdot_unify_thermostat_write_attributes_callback() + { +- for (const auto& callback: uic_mqtt_dotdot_on_off_on_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ return uic_mqtt_dotdot_unify_thermostat_write_attributes_callback; + } +-static inline bool uic_mqtt_dotdot_on_off_toggle_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++void uic_mqtt_dotdot_set_unify_thermostat_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_on_off_toggle_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_on_off_off_with_effect_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_unify_thermostat_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback_t callback) + { +- OffWithEffectEffectIdentifier effect_identifier_value; +- memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- uint8_t effect_variant_value; +- memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); +- for (const auto& callback: uic_mqtt_dotdot_on_off_off_with_effect_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- effect_identifier_value, +- +- effect_variant_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_on_off_on_with_recall_global_scene_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_clear_unify_thermostat_force_read_attributes_callbacks() + { +- for (const auto& callback: uic_mqtt_dotdot_on_off_on_with_recall_global_scene_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_on_off_on_with_timed_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyThermostat/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_unify_thermostat_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- uint8_t on_off_control_value; +- memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- uint16_t on_time_value; +- memset(&on_time_value, 0x00, sizeof(on_time_value)); +- uint16_t off_wait_time_value; +- memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); +- for (const auto& callback: uic_mqtt_dotdot_on_off_on_with_timed_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- on_off_control_value, +- +- on_time_value, +- +- off_wait_time_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.empty()) { ++ return; + } + +- return false; +-} ++ if (message_length == 0) { ++ return; ++ } + +-static inline bool uic_mqtt_dotdot_on_off_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_on_off_write_attributes_callback) { +- uic_mqtt_dotdot_on_off_state_t on_off_new_state = {}; +- uic_mqtt_dotdot_on_off_updated_state_t on_off_new_updated_state = {}; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- on_off_new_state, +- on_off_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ uic_mqtt_dotdot_unify_thermostat_state_t new_state = {}; ++ uic_mqtt_dotdot_unify_thermostat_updated_state_t new_updated_state = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_unify_thermostat_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyThermostat", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat", "WriteAttributes", ""); ++ return; + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_on_off_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_on_off_force_read_attributes_callback) { +- uic_mqtt_dotdot_on_off_updated_state_t on_off_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- on_off_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); + } +- return false; ++ + } + +-// Publishing Supported Commands for OnOff Cluster +-void uic_mqtt_dotdot_on_off_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++static void uic_mqtt_dotdot_on_unify_thermostat_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ uint8_t endpoint = 0; ++ std::string unid; + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_on_off_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Off")"; ++ if ((message_length == 0) || (uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.empty())) { ++ return; + } +- if (uic_mqtt_dotdot_on_off_on_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("On")"; ++ ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +- if (uic_mqtt_dotdot_on_off_toggle_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ ++ try { ++ uic_mqtt_dotdot_unify_thermostat_updated_state_t force_update = {0}; ++ bool trigger_handler = false; ++ ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); ++ ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.thermostat_mode = true; ++ force_update.supported_thermostat_mode = true; ++ force_update.operating_state = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"ThermostatMode", &force_update.thermostat_mode }, ++ {"SupportedThermostatMode", &force_update.supported_thermostat_mode }, ++ {"OperatingState", &force_update.operating_state }, ++ }; ++ ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } + } +- first_command = false; +- ss << R"("Toggle")"; +- } +- if (uic_mqtt_dotdot_on_off_off_with_effect_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } + } +- first_command = false; +- ss << R"("OffWithEffect")"; ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "UnifyThermostat/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; + } +- if (uic_mqtt_dotdot_on_off_on_with_recall_global_scene_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("OnWithRecallGlobalScene")"; ++} ++ ++sl_status_t uic_mqtt_dotdot_unify_thermostat_thermostat_mode_publish( ++ const char *base_topic, ++ uint8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) ++{ ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_THERMOSTAT_THERMOSTAT_MODE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_thermostat_thermostat_mode_get_enum_value_name((uint32_t)value); ++ #elif defined(ENUM8_ENUM_NAME_AVAILABLE) ++ jsn["value"] = enum8_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_THERMOSTAT_THERMOSTAT_MODE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/ThermostatMode", e.what()); ++ return SL_STATUS_OK; + } +- if (uic_mqtt_dotdot_on_off_on_with_timed_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("OnWithTimedOff")"; ++ ++ ++ std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/ThermostatMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } ++ return SL_STATUS_OK; ++} + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_on_off_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++sl_status_t uic_mqtt_dotdot_unify_thermostat_thermostat_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) ++{ ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyThermostat/Attributes/ThermostatMode"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); + } ++ return SL_STATUS_OK; ++} ++// clang-format off + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_on_off_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++sl_status_t uic_mqtt_dotdot_unify_thermostat_supported_thermostat_mode_publish( ++ const char *base_topic, ++ uint16_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) ++{ ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ nlohmann::json bitmap_values = UnifyThermostatSupportedThermostatMode.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/SupportedThermostatMode", e.what()); ++ return SL_STATUS_OK; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/OnOff/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/OnOff/Attributes"; ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/SupportedThermostatMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } ++ return SL_STATUS_OK; + } + +-// Publishing empty/no Supported Commands for OnOff Cluster +-void uic_mqtt_dotdot_on_off_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_thermostat_supported_thermostat_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/OnOff/SupportedCommands"; ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyThermostat/Attributes/SupportedThermostatMode"; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); + } ++ return SL_STATUS_OK; + } ++// clang-format off + +-// Publishing Cluster Revision for Level Cluster +-void uic_mqtt_dotdot_level_publish_cluster_revision(const char* base_topic, uint16_t value) ++sl_status_t uic_mqtt_dotdot_unify_thermostat_operating_state_publish( ++ const char *base_topic, ++ uint8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::string cluster_topic = std::string(base_topic) + "/Level/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_THERMOSTAT_OPERATING_STATE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_thermostat_operating_state_get_enum_value_name((uint32_t)value); ++ #elif defined(ENUM8_ENUM_NAME_AVAILABLE) ++ jsn["value"] = enum8_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_THERMOSTAT_OPERATING_STATE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyThermostat/Attributes/OperatingState", e.what()); ++ return SL_STATUS_OK; ++ } ++ ++ ++ std::string topic = std::string(base_topic) + "/UnifyThermostat/Attributes/OperatingState"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } + +-// Unretain Cluster Revision for Level Cluster +-void uic_mqtt_dotdot_level_unretain_cluster_revision(const char* base_topic) ++sl_status_t uic_mqtt_dotdot_unify_thermostat_operating_state_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on +- std::string cluster_topic ++ std::string topic + = std::string(base_topic) +- + "/Level/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ + "/UnifyThermostat/Attributes/OperatingState"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } ++// clang-format off + +-static inline bool uic_mqtt_dotdot_level_move_to_level_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_thermostat_init() + { +- uint8_t level_value; +- memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_move_to_level_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- level_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string base_topic = "ucl/by-unid/+/+/"; ++ ++ std::string subscription_topic; ++ if(!uic_mqtt_dotdot_unify_thermostat_write_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyThermostat/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_thermostat_WriteAttributes); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_level_move_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- MoveStepMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_move_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- move_mode_value, +- +- rate_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if(!uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyThermostat/Commands/ForceReadAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_thermostat_force_read_attributes); + } + +- return false; ++ // Init the attributes for that cluster ++ uic_mqtt_dotdot_unify_thermostat_attributes_init(); ++ ++ uic_mqtt_dotdot_by_group_unify_thermostat_init(); ++ ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_level_step_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- MoveStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_step_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_level_stop_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// Callbacks pointers ++static std::set uic_mqtt_dotdot_unify_humidity_control_mode_set_callback; ++static std::set uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback; ++static std::set uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback; ++static std::set uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback; ++static std::set uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback; ++static std::set uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback; ++ ++// Callbacks setters ++void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) + { +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_stop_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_level_move_to_level_with_on_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) + { +- uint8_t level_value; +- memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- level_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_level_move_with_on_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_clear() + { +- MoveStepMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_move_with_on_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- move_mode_value, +- +- rate_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_level_step_with_on_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++std::set& get_uic_mqtt_dotdot_unify_humidity_control_mode_set_callback() + { +- MoveStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_step_with_on_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ return uic_mqtt_dotdot_unify_humidity_control_mode_set_callback; + } +-static inline bool uic_mqtt_dotdot_level_stop_with_on_off_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) + { +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_stop_with_on_off_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_level_move_to_closest_frequency_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_mode_set_callback_t callback) + { +- uint16_t frequency_value; +- memset(&frequency_value, 0x00, sizeof(frequency_value)); +- for (const auto& callback: uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- frequency_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.erase(callback); + } +- +-static inline bool uic_mqtt_dotdot_level_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback_clear() + { +- for (const auto& callback: uic_mqtt_dotdot_level_write_attributes_callback) { +- uic_mqtt_dotdot_level_state_t level_new_state = {}; +- uic_mqtt_dotdot_level_updated_state_t level_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- level_new_state, +- level_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.clear(); + } +- +-static inline bool uic_mqtt_dotdot_level_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_level_force_read_attributes_callback) { +- uic_mqtt_dotdot_level_updated_state_t level_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- level_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.insert(callback); + } +- return false; + } +- +-// Publishing Supported Commands for Level Cluster +-void uic_mqtt_dotdot_level_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_level_move_to_level_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("MoveToLevel")"; +- } +- if (uic_mqtt_dotdot_level_move_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Move")"; +- } +- if (uic_mqtt_dotdot_level_step_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Step")"; +- } +- if (uic_mqtt_dotdot_level_stop_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Stop")"; +- } +- if (uic_mqtt_dotdot_level_move_to_level_with_on_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("MoveToLevelWithOnOff")"; +- } +- if (uic_mqtt_dotdot_level_move_with_on_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("MoveWithOnOff")"; +- } +- if (uic_mqtt_dotdot_level_step_with_on_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("StepWithOnOff")"; +- } +- if (uic_mqtt_dotdot_level_stop_with_on_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("StopWithOnOff")"; +- } +- if (uic_mqtt_dotdot_level_move_to_closest_frequency_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("MoveToClosestFrequency")"; +- } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_level_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_level_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Level/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Level/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.erase(callback); + } +- +-// Publishing empty/no Supported Commands for Level Cluster +-void uic_mqtt_dotdot_level_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_clear() + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Level/SupportedCommands"; ++ uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.clear(); ++} ++std::set& get_uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback() ++{ ++ return uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback; ++} + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_set(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) ++{ ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.insert(callback); + } + } +- +-// Publishing Cluster Revision for Alarms Cluster +-void uic_mqtt_dotdot_alarms_publish_cluster_revision(const char* base_topic, uint16_t value) ++void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_unset(const uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_t callback) + { +- std::string cluster_topic = std::string(base_topic) + "/Alarms/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.erase(callback); + } +- +-// Unretain Cluster Revision for Alarms Cluster +-void uic_mqtt_dotdot_alarms_unretain_cluster_revision(const char* base_topic) ++void uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback_clear() + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Alarms/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.clear(); + } + +-static inline bool uic_mqtt_dotdot_alarms_reset_alarm_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_set_unify_humidity_control_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback_t callback) + { +- uint8_t alarm_code_value; +- memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; +- memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- for (const auto& callback: uic_mqtt_dotdot_alarms_reset_alarm_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- alarm_code_value, +- +- cluster_identifier_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_alarms_alarm_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_unify_humidity_control_write_attributes_callback( ++ const uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback_t callback) + { +- uint8_t alarm_code_value; +- memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; +- memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- for (const auto& callback: uic_mqtt_dotdot_alarms_alarm_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- alarm_code_value, +- +- cluster_identifier_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.erase(callback); + } +-static inline bool uic_mqtt_dotdot_alarms_reset_all_alarms_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_clear_unify_humidity_control_write_attributes_callbacks() + { +- for (const auto& callback: uic_mqtt_dotdot_alarms_reset_all_alarms_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.clear(); + } +-static inline bool uic_mqtt_dotdot_alarms_get_alarm_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++std::set& get_uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback() + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t alarm_code_value; +- memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; +- memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- uint32_t time_stamp_value; +- memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); +- for (const auto& callback: uic_mqtt_dotdot_alarms_get_alarm_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value, +- +- alarm_code_value, +- +- cluster_identifier_value, +- +- time_stamp_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ return uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback; + } +-static inline bool uic_mqtt_dotdot_alarms_get_alarm_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++void uic_mqtt_dotdot_set_unify_humidity_control_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_alarms_get_alarm_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (callback != nullptr) { ++ uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.insert(callback); + } +- +- return false; + } +-static inline bool uic_mqtt_dotdot_alarms_reset_alarm_log_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_unset_unify_humidity_control_force_read_attributes_callback( ++ const uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback_t callback) + { +- for (const auto& callback: uic_mqtt_dotdot_alarms_reset_alarm_log_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.erase(callback); + } +- +-static inline bool uic_mqtt_dotdot_alarms_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++void uic_mqtt_dotdot_clear_unify_humidity_control_force_read_attributes_callbacks() + { +- for (const auto& callback: uic_mqtt_dotdot_alarms_write_attributes_callback) { +- uic_mqtt_dotdot_alarms_state_t alarms_new_state = {}; +- uic_mqtt_dotdot_alarms_updated_state_t alarms_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- alarms_new_state, +- alarms_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; ++ uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.clear(); + } + +-static inline bool uic_mqtt_dotdot_alarms_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_alarms_force_read_attributes_callback) { +- uic_mqtt_dotdot_alarms_updated_state_t alarms_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- alarms_force_update +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} + +-// Publishing Supported Commands for Alarms Cluster +-void uic_mqtt_dotdot_alarms_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/ModeSet ++void uic_mqtt_dotdot_on_unify_humidity_control_mode_set( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_alarms_reset_alarm_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ResetAlarm")"; +- } +- if (uic_mqtt_dotdot_alarms_alarm_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Alarm")"; +- } +- if (uic_mqtt_dotdot_alarms_reset_all_alarms_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ResetAllAlarms")"; +- } +- if (uic_mqtt_dotdot_alarms_get_alarm_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetAlarmResponse")"; +- } +- if (uic_mqtt_dotdot_alarms_get_alarm_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetAlarm")"; +- } +- if (uic_mqtt_dotdot_alarms_reset_alarm_log_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ResetAlarmLog")"; ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.empty())) { ++ return; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_alarms_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_alarms_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ModeType mode = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_unify_humidity_control_mode_set( ++ jsn, ++ mode ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "ModeSet"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", ""); ++ return; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Alarms/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Alarms/Attributes"; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_mode_set_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ mode ++ ++ ); + } ++ + } + +-// Publishing empty/no Supported Commands for Alarms Cluster +-void uic_mqtt_dotdot_alarms_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/GeneratedCommands/ModeSet ++static void uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Alarms/SupportedCommands"; ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.empty())) { ++ return; ++ } + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } +-} + +-// Publishing Cluster Revision for Time Cluster +-void uic_mqtt_dotdot_time_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/Time/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} ++ ModeType mode = {}; + +-// Unretain Cluster Revision for Time Cluster +-void uic_mqtt_dotdot_time_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Time/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} + ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +-static inline bool uic_mqtt_dotdot_time_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_time_write_attributes_callback) { +- uic_mqtt_dotdot_time_state_t time_new_state = {}; +- uic_mqtt_dotdot_time_updated_state_t time_new_updated_state = {}; ++ ++ uic_mqtt_dotdot_parse_unify_humidity_control_mode_set( ++ jsn, ++ mode ++ ); + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- time_new_state, +- time_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "ModeSet"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "ModeSet", ""); ++ return; + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_time_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_time_force_read_attributes_callback) { +- uic_mqtt_dotdot_time_updated_state_t time_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- time_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ mode ++ ++ ); + } +- return false; + } + +-// Publishing Supported Commands for Time Cluster +-void uic_mqtt_dotdot_time_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_time_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/SetpointSet ++void uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.empty())) { ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_time_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Time/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Time/Attributes"; ++ SetpointType type = {}; ++ int8_t precision = {}; ++ int8_t scale = {}; ++ int32_t value = {}; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } +-} + +-// Publishing empty/no Supported Commands for Time Cluster +-void uic_mqtt_dotdot_time_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Time/SupportedCommands"; ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} ++ ++ uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( ++ jsn, ++ type, + +-// Publishing Cluster Revision for PollControl Cluster +-void uic_mqtt_dotdot_poll_control_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/PollControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} ++ precision, + +-// Unretain Cluster Revision for PollControl Cluster +-void uic_mqtt_dotdot_poll_control_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/PollControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} ++ scale, + +-static inline bool uic_mqtt_dotdot_poll_control_check_in_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_poll_control_check_in_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ value ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "SetpointSet"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", ""); ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_poll_control_check_in_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- bool start_fast_polling_value; +- memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- uint16_t fast_poll_timeout_value; +- memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); +- for (const auto& callback: uic_mqtt_dotdot_poll_control_check_in_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- start_fast_polling_value, +- +- fast_poll_timeout_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ type, ++ ++ precision, ++ ++ scale, ++ ++ value ++ ++ ); + } + +- return false; + } +-static inline bool uic_mqtt_dotdot_poll_control_fast_poll_stop_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/GeneratedCommands/SetpointSet ++static void uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- for (const auto& callback: uic_mqtt_dotdot_poll_control_fast_poll_stop_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (message_length == 0 || (uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.empty())) { ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_poll_control_set_long_poll_interval_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint32_t new_long_poll_interval_value; +- memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); +- for (const auto& callback: uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- new_long_poll_interval_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_poll_control_set_short_poll_interval_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t new_short_poll_interval_value; +- memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); +- for (const auto& callback: uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- new_short_poll_interval_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ SetpointType type = {}; ++ int8_t precision = {}; ++ int8_t scale = {}; ++ int32_t value = {}; + +- return false; +-} + +-static inline bool uic_mqtt_dotdot_poll_control_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_poll_control_write_attributes_callback) { +- uic_mqtt_dotdot_poll_control_state_t poll_control_new_state = {}; +- uic_mqtt_dotdot_poll_control_updated_state_t poll_control_new_updated_state = {}; ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- poll_control_new_state, +- poll_control_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( ++ jsn, ++ type, ++ ++ precision, ++ ++ scale, ++ ++ value ++ ); ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "SetpointSet"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "SetpointSet", ""); ++ return; + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_poll_control_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_poll_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_poll_control_updated_state_t poll_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- poll_control_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ type, ++ ++ precision, ++ ++ scale, ++ ++ value ++ ++ ); + } +- return false; + } + +-// Publishing Supported Commands for PollControl Cluster +-void uic_mqtt_dotdot_poll_control_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_poll_control_check_in_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("CheckIn")"; +- } +- if (uic_mqtt_dotdot_poll_control_check_in_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("CheckInResponse")"; +- } +- if (uic_mqtt_dotdot_poll_control_fast_poll_stop_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("FastPollStop")"; +- } +- if (uic_mqtt_dotdot_poll_control_set_long_poll_interval_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetLongPollInterval")"; +- } +- if (uic_mqtt_dotdot_poll_control_set_short_poll_interval_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetShortPollInterval")"; ++// Callback function for incoming publications on ucl/by-unid/+/+/UnifyHumidityControl/Commands/WriteAttributes ++void uic_mqtt_dotdot_on_unify_humidity_control_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if (uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.empty()) { ++ return; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_poll_control_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ if (message_length == 0) { ++ return; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_poll_control_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PollControl/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PollControl/Attributes"; ++ uic_mqtt_dotdot_unify_humidity_control_state_t new_state = {}; ++ uic_mqtt_dotdot_unify_humidity_control_updated_state_t new_updated_state = {}; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_unify_humidity_control_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyHumidityControl", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl", "WriteAttributes", ""); ++ return; ++ } ++ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback){ ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ new_state, ++ new_updated_state ++ ); + } ++ + } + +-// Publishing empty/no Supported Commands for PollControl Cluster +-void uic_mqtt_dotdot_poll_control_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static void uic_mqtt_dotdot_on_unify_humidity_control_force_read_attributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PollControl/SupportedCommands"; ++ uint8_t endpoint = 0; ++ std::string unid; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if ((message_length == 0) || (uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.empty())) { ++ return; + } +-} + +-// Publishing Cluster Revision for ShadeConfiguration Cluster +-void uic_mqtt_dotdot_shade_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/ShadeConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} ++ if(! uic_dotdot_mqtt::parse_topic(topic, unid, endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } + +-// Unretain Cluster Revision for ShadeConfiguration Cluster +-void uic_mqtt_dotdot_shade_configuration_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/ShadeConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} ++ try { ++ uic_mqtt_dotdot_unify_humidity_control_updated_state_t force_update = {0}; ++ bool trigger_handler = false; + ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ std::vector attributes = jsn["value"].get>(); + +-static inline bool uic_mqtt_dotdot_shade_configuration_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_shade_configuration_write_attributes_callback) { +- uic_mqtt_dotdot_shade_configuration_state_t shade_configuration_new_state = {}; +- uic_mqtt_dotdot_shade_configuration_updated_state_t shade_configuration_new_updated_state = {}; ++ // Assume all attributes to be read on empty array received ++ if (attributes.size() == 0) { ++ force_update.reporting_mode = true; ++ force_update.supported_reporting_mode = true; ++ force_update.current_state = true; ++ force_update.supported_set_points = true; ++ force_update.humidifier_setpoint_min = true; ++ force_update.humidifier_setpoint_max = true; ++ force_update.humidifier_setpoint = true; ++ force_update.humidifier_setpoint_scale = true; ++ force_update.humidifier_setpoint_precision = true; ++ force_update.dehumidifier_setpoint_min = true; ++ force_update.dehumidifier_setpoint_max = true; ++ force_update.dehumidifier_setpoint = true; ++ force_update.dehumidifier_setpoint_scale = true; ++ force_update.dehumidifier_setpoint_precision = true; ++ force_update.auto_setpoint_min = true; ++ force_update.auto_setpoint_max = true; ++ force_update.auto_setpoint = true; ++ force_update.auto_setpoint_scale = true; ++ force_update.auto_setpoint_precision = true; ++ trigger_handler = true; ++ } else { ++ std::unordered_map supported_attrs = { ++ {"ReportingMode", &force_update.reporting_mode }, ++ {"SupportedReportingMode", &force_update.supported_reporting_mode }, ++ {"CurrentState", &force_update.current_state }, ++ {"SupportedSetPoints", &force_update.supported_set_points }, ++ {"HumidifierSetpointMin", &force_update.humidifier_setpoint_min }, ++ {"HumidifierSetpointMax", &force_update.humidifier_setpoint_max }, ++ {"HumidifierSetpoint", &force_update.humidifier_setpoint }, ++ {"HumidifierSetpointScale", &force_update.humidifier_setpoint_scale }, ++ {"HumidifierSetpointPrecision", &force_update.humidifier_setpoint_precision }, ++ {"DehumidifierSetpointMin", &force_update.dehumidifier_setpoint_min }, ++ {"DehumidifierSetpointMax", &force_update.dehumidifier_setpoint_max }, ++ {"DehumidifierSetpoint", &force_update.dehumidifier_setpoint }, ++ {"DehumidifierSetpointScale", &force_update.dehumidifier_setpoint_scale }, ++ {"DehumidifierSetpointPrecision", &force_update.dehumidifier_setpoint_precision }, ++ {"AutoSetpointMin", &force_update.auto_setpoint_min }, ++ {"AutoSetpointMax", &force_update.auto_setpoint_max }, ++ {"AutoSetpoint", &force_update.auto_setpoint }, ++ {"AutoSetpointScale", &force_update.auto_setpoint_scale }, ++ {"AutoSetpointPrecision", &force_update.auto_setpoint_precision }, ++ }; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- shade_configuration_new_state, +- shade_configuration_new_updated_state +- ) == SL_STATUS_OK) { +- return true; ++ for (auto& attribute : attributes) { ++ auto found_attr = supported_attrs.find(attribute); ++ if (found_attr != supported_attrs.end()) { ++ *(found_attr->second) = true; ++ trigger_handler = true; ++ } ++ } + } +- } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_shade_configuration_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_shade_configuration_force_read_attributes_callback) { +- uic_mqtt_dotdot_shade_configuration_updated_state_t shade_configuration_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- shade_configuration_force_update +- ) == SL_STATUS_OK) { +- return true; ++ if (trigger_handler == true) { ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback) { ++ callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, ++ force_update ++ ); ++ } + } ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "UnifyHumidityControl/Commands/ForceReadAttributes: Unable to parse JSON payload"); ++ return; + } +- return false; + } + +-// Publishing Supported Commands for ShadeConfiguration Cluster +-void uic_mqtt_dotdot_shade_configuration_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_reporting_mode_publish( ++ const char *base_topic, ++ ModeType value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ nlohmann::json jsn; + +- // check if there is callback for each command ++ // This is a single value + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_shade_configuration_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } ++ #ifdef UNIFY_HUMIDITY_CONTROL_REPORTING_MODE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_humidity_control_reporting_mode_get_enum_value_name((uint32_t)value); ++ #elif defined(MODE_TYPE_ENUM_NAME_AVAILABLE) ++ jsn["value"] = mode_type_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_REPORTING_MODE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_shade_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/ReportingMode", e.what()); ++ return SL_STATUS_OK; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ShadeConfiguration/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ShadeConfiguration/Attributes"; + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/ReportingMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } ++ return SL_STATUS_OK; + } + +-// Publishing empty/no Supported Commands for ShadeConfiguration Cluster +-void uic_mqtt_dotdot_shade_configuration_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_reporting_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ShadeConfiguration/SupportedCommands"; ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/ReportingMode"; + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); + } +-} ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; ++} ++// clang-format off + +-// Publishing Cluster Revision for DoorLock Cluster +-void uic_mqtt_dotdot_door_lock_publish_cluster_revision(const char* base_topic, uint16_t value) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_reporting_mode_publish( ++ const char *base_topic, ++ uint8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- std::string cluster_topic = std::string(base_topic) + "/DoorLock/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ nlohmann::json bitmap_values = UnifyHumidityControlSupportedReportingMode.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/SupportedReportingMode", e.what()); ++ return SL_STATUS_OK; ++ } ++ ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/SupportedReportingMode"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } + +-// Unretain Cluster Revision for DoorLock Cluster +-void uic_mqtt_dotdot_door_lock_unretain_cluster_revision(const char* base_topic) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_reporting_mode_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { + // clang-format on +- std::string cluster_topic ++ std::string topic + = std::string(base_topic) +- + "/DoorLock/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ + "/UnifyHumidityControl/Attributes/SupportedReportingMode"; ++ ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } ++// clang-format off + +-static inline bool uic_mqtt_dotdot_door_lock_lock_door_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_current_state_publish( ++ const char *base_topic, ++ uint8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- const char* pin_or_rfid_code_value; +- memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_lock_door_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- pin_or_rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_HUMIDITY_CONTROL_CURRENT_STATE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_humidity_control_current_state_get_enum_value_name((uint32_t)value); ++ #elif defined(ENUM8_ENUM_NAME_AVAILABLE) ++ jsn["value"] = enum8_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_CURRENT_STATE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/CurrentState", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/CurrentState"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_lock_door_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_current_state_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_lock_door_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/CurrentState"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_unlock_door_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_set_points_publish( ++ const char *base_topic, ++ uint8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- const char* pin_or_rfid_code_value; +- memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_door_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- pin_or_rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ nlohmann::json bitmap_values = UnifyHumidityControlSupportedSetPoints.get_bitmap_values_as_json_tree((uint32_t)value); ++ jsn["value"] = bitmap_values; ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/SupportedSetPoints", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ boost::replace_all(payload_str, "\"true\"", "true"); ++ boost::replace_all(payload_str, "\"false\"", "false"); ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/SupportedSetPoints"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_unlock_door_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_supported_set_points_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_door_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/SupportedSetPoints"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_toggle_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_min_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- const char* pin_or_rfid_code_value; +- memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_toggle_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- pin_or_rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,5,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,5,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_toggle_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_toggle_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointMin", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointMin"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_unlock_with_timeout_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_min_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t timeout_in_seconds_value; +- memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- const char* pin_or_rfid_code_value; +- memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- timeout_in_seconds_value, +- +- pin_or_rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/HumidifierSetpointMin"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_max_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,6,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,6,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_log_record_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t log_index_value; +- memset(&log_index_value, 0x00, sizeof(log_index_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- log_index_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointMax", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointMax"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_log_record_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_max_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t log_entryid_value; +- memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- uint32_t timestamp_value; +- memset(×tamp_value, 0x00, sizeof(timestamp_value)); +- GetLogRecordResponseEventType event_type_value; +- memset(&event_type_value, 0x00, sizeof(event_type_value)); +- DrlkOperEventSource source_operation_event_value; +- memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- uint8_t event_id_or_alarm_code_value; +- memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; +- memset(&pin_value, 0x00, sizeof(pin_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- log_entryid_value, +- +- timestamp_value, +- +- event_type_value, +- +- source_operation_event_value, +- +- event_id_or_alarm_code_value, +- +- userid_value, +- +- pin_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/HumidifierSetpointMax"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_pin_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkSettableUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* pin_value; +- memset(&pin_value, 0x00, sizeof(pin_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_pin_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value, +- +- user_type_value, +- +- pin_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++// clang-format off + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_pin_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkSetCodeStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_pin_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ nlohmann::json jsn; + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,7,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,7,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* code_value; +- memset(&code_value, 0x00, sizeof(code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value, +- +- user_type_value, +- +- code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpoint", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpoint"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_pin_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/HumidifierSetpoint"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_pin_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_publish( ++ const char *base_topic, ++ ScaleType value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_pin_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_SCALE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_humidity_control_humidifier_setpoint_scale_get_enum_value_name((uint32_t)value); ++ #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) ++ jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_SCALE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointScale", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointScale"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_all_pin_codes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_pin_codes_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/HumidifierSetpointScale"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( ++ const char *base_topic, ++ int8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,9,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,9,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_user_status_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkSettableUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_status_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/HumidifierSetpointPrecision", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/HumidifierSetpointPrecision"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_user_status_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_status_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/HumidifierSetpointPrecision"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_user_status_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_min_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_status_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,10,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,10,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_user_status_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointMin", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMin"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_weekday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_min_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t days_mask_value; +- memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; +- memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; +- memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; +- memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; +- memset(&end_minute_value, 0x00, sizeof(end_minute_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value, +- +- days_mask_value, +- +- start_hour_value, +- +- start_minute_value, +- +- end_hour_value, +- +- end_minute_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMin"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_max_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,11,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,11,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t days_mask_value; +- memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; +- memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; +- memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; +- memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; +- memset(&end_minute_value, 0x00, sizeof(end_minute_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value, +- +- status_value, +- +- days_mask_value, +- +- start_hour_value, +- +- start_minute_value, +- +- end_hour_value, +- +- end_minute_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointMax", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMax"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_weekday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_max_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/DehumidifierSetpointMax"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,12,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,12,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_year_day_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- uint32_t local_start_time_value; +- memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; +- memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value, +- +- local_start_time_value, +- +- local_end_time_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpoint", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpoint"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/DehumidifierSetpoint"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_publish( ++ const char *base_topic, ++ ScaleType value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_SCALE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_humidity_control_dehumidifier_setpoint_scale_get_enum_value_name((uint32_t)value); ++ #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) ++ jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_SCALE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointScale", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointScale"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; +- memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; +- memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value, +- +- status_value, +- +- local_start_time_value, +- +- local_end_time_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/DehumidifierSetpointScale"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_year_day_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( ++ const char *base_topic, ++ int8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- uint8_t scheduleid_value; +- memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- scheduleid_value, +- +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,14,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,14,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_holiday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint8_t holiday_scheduleid_value; +- memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- uint32_t local_start_time_value; +- memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; +- memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); +- DrlkOperMode operating_mode_during_holiday_value; +- memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- holiday_scheduleid_value, +- +- local_start_time_value, +- +- local_end_time_value, +- +- operating_mode_during_holiday_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/DehumidifierSetpointPrecision"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,15,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,15,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t holiday_scheduleid_value; +- memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- holiday_scheduleid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointMin", e.what()); ++ return SL_STATUS_OK; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t holiday_scheduleid_value; +- memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- zclStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; +- memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; +- memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); +- DrlkOperMode operating_mode_during_holiday_value; +- memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- holiday_scheduleid_value, +- +- status_value, +- +- local_start_time_value, +- +- local_end_time_value, +- +- operating_mode_during_holiday_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_holiday_schedule_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t holiday_scheduleid_value; +- memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- holiday_scheduleid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointMin"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); + } +- +- return false; ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_user_type_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_type_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_type_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_user_type_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_min_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_type_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/AutoSetpointMin"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_user_type_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_type_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,16,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,16,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_user_type_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_type_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointMax", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointMax"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_rfid_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_max_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkSettableUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; +- memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value, +- +- user_type_value, +- +- rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/AutoSetpointMax"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_set_rfid_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_publish( ++ const char *base_topic, ++ int32_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- DrlkSetCodeStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_rfid_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,17,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,17,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpoint", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpoint"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- DrlkUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; +- memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value, +- +- user_status_value, +- +- user_type_value, +- +- rfid_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/AutoSetpoint"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_rfid_code_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_publish( ++ const char *base_topic, ++ ScaleType value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- userid_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ #ifdef UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_SCALE_ENUM_NAME_AVAILABLE ++ jsn["value"] = unify_humidity_control_auto_setpoint_scale_get_enum_value_name((uint32_t)value); ++ #elif defined(SCALE_TYPE_ENUM_NAME_AVAILABLE) ++ jsn["value"] = scale_type_get_enum_value_name((uint32_t)value); ++ #else ++ sl_log_warning(LOG_TAG,"Warning: Enum name not available for UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_SCALE. Using number instead."); ++ jsn["value"] = static_cast(value); ++ #endif ++ ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointScale", e.what()); ++ return SL_STATUS_OK; + } + +- return false; ++ ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointScale"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_rfid_code_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_rfid_code_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/AutoSetpointScale"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( ++ const char *base_topic, ++ int8_t value, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type ++) + { +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ nlohmann::json jsn; ++ ++ // This is a single value ++ ++ if (true == uic_dotdot_has_attribute_value_a_name(64928,19,value)) { ++ jsn["value"] = uic_dotdot_get_attribute_value_name(64928,19,value); ++ }else{ ++ jsn["value"] = value; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DrlkPassFailStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- status_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ std::string payload_str; ++ try { ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ payload_str = jsn.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ } catch (const nlohmann::json::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyHumidityControl/Attributes/AutoSetpointPrecision", e.what()); ++ return SL_STATUS_OK; + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_user_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DataOperationTypeEnum operation_type_value; +- memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- uint16_t user_index_value; +- memset(&user_index_value, 0x00, sizeof(user_index_value)); +- const char* user_name_value; +- memset(&user_name_value, 0x00, sizeof(user_name_value)); +- uint32_t user_uniqueid_value; +- memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); +- DrlkSettableUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- CredentialRuleEnum credential_rule_value; +- memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- operation_type_value, +- +- user_index_value, +- +- user_name_value, +- +- user_uniqueid_value, +- +- user_status_value, +- +- user_type_value, +- +- credential_rule_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } + +- return false; ++ std::string topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/AutoSetpointPrecision"; ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ if (publish_type & UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_user_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_unretain( ++ const char *base_topic, ++ uic_mqtt_dotdot_attribute_publish_type_t publish_type) + { +- uint16_t user_index_value; +- memset(&user_index_value, 0x00, sizeof(user_index_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- user_index_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ // clang-format on ++ std::string topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/AutoSetpointPrecision"; + +- return false; ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_DESIRED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_desired = topic + "/Desired"; ++ uic_mqtt_publish(topic_desired.c_str(), NULL, 0, true); ++ } ++ if ((publish_type == UCL_MQTT_PUBLISH_TYPE_REPORTED) ++ || (publish_type == UCL_MQTT_PUBLISH_TYPE_ALL)) { ++ std::string topic_reported = topic + "/Reported"; ++ uic_mqtt_publish(topic_reported.c_str(), NULL, 0, true); ++ } ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_get_user_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) ++// clang-format off ++ ++ ++sl_status_t uic_mqtt_dotdot_unify_humidity_control_init() + { +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ std::string base_topic = "ucl/by-unid/+/+/"; ++ ++ std::string subscription_topic; ++ if(!uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_WriteAttributes); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_user_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t user_index_value; +- memset(&user_index_value, 0x00, sizeof(user_index_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_user_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- user_index_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if(!uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/Commands/ForceReadAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_force_read_attributes); ++ } ++ if (!uic_mqtt_dotdot_unify_humidity_control_mode_set_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/Commands/ModeSet"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_mode_set); ++ } ++ if (!uic_mqtt_dotdot_unify_humidity_control_generated_mode_set_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/GeneratedCommands/ModeSet"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_humidity_control_mode_set); ++ } ++ if (!uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/Commands/SetpointSet"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set); ++ } ++ if (!uic_mqtt_dotdot_unify_humidity_control_generated_setpoint_set_callback.empty()) { ++ subscription_topic = base_topic + "UnifyHumidityControl/GeneratedCommands/SetpointSet"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set); + } + +- return false; ++ // Init the attributes for that cluster ++ uic_mqtt_dotdot_unify_humidity_control_attributes_init(); ++ ++ uic_mqtt_dotdot_by_group_unify_humidity_control_init(); ++ ++ return SL_STATUS_OK; + } +-static inline bool uic_mqtt_dotdot_door_lock_operating_event_notification_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DrlkOperEventSource operation_event_source_value; +- memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); +- OperatingEventNotificationOperationEventCode operation_event_code_value; +- memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; +- memset(&pin_value, 0x00, sizeof(pin_value)); +- uint32_t local_time_value; +- memset(&local_time_value, 0x00, sizeof(local_time_value)); +- const char* data_value; +- memset(&data_value, 0x00, sizeof(data_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_operating_event_notification_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- operation_event_source_value, +- +- operation_event_code_value, +- +- userid_value, +- +- pin_value, +- +- local_time_value, +- +- data_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ ++ ++sl_status_t uic_mqtt_dotdot_init() { ++ ++ sl_status_t status_flag = SL_STATUS_OK; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_basic_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_programming_event_notification_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- ProgrammingEventNotificationProgramEventSource program_event_source_value; +- memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); +- ProgrammingEventNotificationProgramEventCode program_event_code_value; +- memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- uint16_t userid_value; +- memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; +- memset(&pin_value, 0x00, sizeof(pin_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- DrlkUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- uint32_t local_time_value; +- memset(&local_time_value, 0x00, sizeof(local_time_value)); +- const char* data_value; +- memset(&data_value, 0x00, sizeof(data_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_programming_event_notification_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- program_event_source_value, +- +- program_event_code_value, +- +- userid_value, +- +- pin_value, +- +- user_type_value, +- +- user_status_value, +- +- local_time_value, +- +- data_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_power_configuration_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_credential_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- DataOperationTypeEnum operation_type_value; +- memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- CredentialStruct credential_value; +- memset(&credential_value, 0x00, sizeof(credential_value)); +- const char* credential_data_value; +- memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- uint16_t user_index_value; +- memset(&user_index_value, 0x00, sizeof(user_index_value)); +- DrlkSettableUserStatus user_status_value; +- memset(&user_status_value, 0x00, sizeof(user_status_value)); +- DrlkUserType user_type_value; +- memset(&user_type_value, 0x00, sizeof(user_type_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_credential_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- operation_type_value, +- +- credential_value, +- +- credential_data_value, +- +- user_index_value, +- +- user_status_value, +- +- user_type_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_device_temperature_configuration_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_set_credential_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_door_lock_set_credential_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_identify_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_credential_status_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- CredentialStruct credential_value; +- memset(&credential_value, 0x00, sizeof(credential_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_credential_status_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- credential_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_groups_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_get_credential_status_response_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_door_lock_get_credential_status_response_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_scenes_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_clear_credential_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- CredentialStruct credential_value; +- memset(&credential_value, 0x00, sizeof(credential_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_credential_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- credential_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_on_off_init(); + } + +- return false; +-} +-static inline bool uic_mqtt_dotdot_door_lock_unbolt_door_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- const char* pin_code_value; +- memset(&pin_code_value, 0x00, sizeof(pin_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_door_lock_unbolt_door_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- pin_code_value +- +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_level_init(); + } + +- return false; +-} ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_alarms_init(); ++ } + +-static inline bool uic_mqtt_dotdot_door_lock_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_door_lock_write_attributes_callback) { +- uic_mqtt_dotdot_door_lock_state_t door_lock_new_state = {}; +- uic_mqtt_dotdot_door_lock_updated_state_t door_lock_new_updated_state = {}; ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_time_init(); ++ } + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- door_lock_new_state, +- door_lock_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_poll_control_init(); + } +- return false; +-} + +-static inline bool uic_mqtt_dotdot_door_lock_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_door_lock_force_read_attributes_callback) { +- uic_mqtt_dotdot_door_lock_updated_state_t door_lock_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- door_lock_force_update +- ) == SL_STATUS_OK) { +- return true; +- } ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_shade_configuration_init(); + } +- return false; +-} + +-// Publishing Supported Commands for DoorLock Cluster +-void uic_mqtt_dotdot_door_lock_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_door_lock_init(); ++ } + +- // check if there is callback for each command +- if (uic_mqtt_dotdot_door_lock_lock_door_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("LockDoor")"; ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_window_covering_init(); + } +- if (uic_mqtt_dotdot_door_lock_lock_door_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("LockDoorResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_barrier_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_unlock_door_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UnlockDoor")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_pump_configuration_and_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_unlock_door_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UnlockDoorResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_thermostat_init(); + } +- if (uic_mqtt_dotdot_door_lock_toggle_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Toggle")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_fan_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_toggle_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ToggleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_dehumidification_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_unlock_with_timeout_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UnlockWithTimeout")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_thermostat_user_interface_configuration_init(); + } +- if (uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UnlockWithTimeoutResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_color_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_log_record_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetLogRecord")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_ballast_configuration_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_log_record_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetLogRecordResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_illuminance_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_pin_code_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetPINCode")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_illuminance_level_sensing_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_pin_code_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetPINCodeResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_temperature_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_pin_code_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetPINCode")"; +- } +- if (uic_mqtt_dotdot_door_lock_get_pin_code_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetPINCodeResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_pressure_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_pin_code_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearPINCode")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_flow_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_pin_code_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearPINCodeResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_relativity_humidity_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_all_pin_codes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearAllPINCodes")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_occupancy_sensing_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearAllPINCodesResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_soil_moisture_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_user_status_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetUserStatus")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_ph_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_user_status_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetUserStatusResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_electrical_conductivity_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_user_status_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetUserStatus")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_wind_speed_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_user_status_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetUserStatusResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_carbon_monoxide_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_weekday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetWeekdaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_carbon_dioxide_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetWeekdayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_pm25_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_weekday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetWeekdaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_ias_zone_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetWeekdayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_iaswd_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_weekday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearWeekdaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_metering_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearWeekdayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_electrical_measurement_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_year_day_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetYearDaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_diagnostics_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetYearDayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_protocol_controller_rf_telemetry_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_year_day_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetYearDaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_state_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetYearDayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_binding_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_year_day_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearYearDaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_system_metrics_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearYearDayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_application_monitoring_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_holiday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetHolidaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_name_and_location_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetHolidayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_configuration_parameters_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_holiday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetHolidaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_user_credential_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetHolidayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_protocol_controller_network_management_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_holiday_schedule_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearHolidaySchedule")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_descriptor_init(); + } +- if (uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearHolidayScheduleResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_unify_fan_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_user_type_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetUserType")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_unify_thermostat_init(); + } +- if (uic_mqtt_dotdot_door_lock_set_user_type_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetUserTypeResponse")"; ++ ++ if (status_flag == SL_STATUS_OK) { ++ status_flag = uic_mqtt_dotdot_unify_humidity_control_init(); + } +- if (uic_mqtt_dotdot_door_lock_get_user_type_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ ++ ++ return status_flag; ++} ++ ++// Publish all supported dotdot cluster commands per each endpoints. ++void uic_mqtt_dotdot_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uic_mqtt_dotdot_basic_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_power_configuration_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_device_temperature_configuration_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_identify_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_groups_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_scenes_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_on_off_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_level_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_alarms_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_time_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_poll_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_shade_configuration_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_door_lock_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_window_covering_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_barrier_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_thermostat_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_fan_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_dehumidification_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_color_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ballast_configuration_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_illuminance_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_temperature_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pressure_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_flow_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_relativity_humidity_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_soil_moisture_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ph_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_wind_speed_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_carbon_monoxide_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_carbon_dioxide_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pm25_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ias_zone_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_iaswd_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_metering_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_electrical_measurement_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_diagnostics_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_supported_commands(unid, 0); ++ uic_mqtt_dotdot_state_publish_supported_commands(unid, 0); ++ uic_mqtt_dotdot_binding_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_system_metrics_publish_supported_commands(unid, 0); ++ uic_mqtt_dotdot_application_monitoring_publish_supported_commands(unid, 0); ++ uic_mqtt_dotdot_name_and_location_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_configuration_parameters_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_user_credential_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_commands(unid, 0); ++ uic_mqtt_dotdot_descriptor_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_fan_control_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_thermostat_publish_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_humidity_control_publish_supported_commands(unid, endpoint_id); ++} ++ ++void uic_mqtt_dotdot_publish_empty_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uic_mqtt_dotdot_basic_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_power_configuration_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_device_temperature_configuration_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_identify_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_groups_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_scenes_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_on_off_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_level_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_alarms_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_time_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_poll_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_shade_configuration_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_door_lock_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_window_covering_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pump_configuration_and_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_thermostat_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_fan_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_dehumidification_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_color_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_illuminance_level_sensing_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_temperature_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_relativity_humidity_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_wind_speed_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_carbon_monoxide_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_carbon_dioxide_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_pm25_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_ias_zone_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_iaswd_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_metering_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_diagnostics_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_empty_supported_commands(unid); ++ uic_mqtt_dotdot_state_publish_empty_supported_commands(unid); ++ uic_mqtt_dotdot_binding_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_system_metrics_publish_empty_supported_commands(unid); ++ uic_mqtt_dotdot_application_monitoring_publish_empty_supported_commands(unid); ++ uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_user_credential_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_protocol_controller_network_management_publish_empty_supported_commands(unid); ++ uic_mqtt_dotdot_descriptor_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_fan_control_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_thermostat_publish_empty_supported_commands(unid, endpoint_id); ++ uic_mqtt_dotdot_unify_humidity_control_publish_empty_supported_commands(unid, endpoint_id); ++} ++ ++// Publishing Cluster Revision for Basic Cluster ++void uic_mqtt_dotdot_basic_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/Basic/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for Basic Cluster ++void uic_mqtt_dotdot_basic_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/Basic/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_basic_reset_to_factory_defaults_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_basic_reset_to_factory_defaults_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("GetUserType")"; + } +- if (uic_mqtt_dotdot_door_lock_get_user_type_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_basic_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_basic_write_attributes_callback) { ++ uic_mqtt_dotdot_basic_state_t basic_new_state = {}; ++ uic_mqtt_dotdot_basic_updated_state_t basic_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ basic_new_state, ++ basic_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("GetUserTypeResponse")"; + } +- if (uic_mqtt_dotdot_door_lock_set_rfid_code_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_basic_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_basic_force_read_attributes_callback) { ++ uic_mqtt_dotdot_basic_updated_state_t basic_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ basic_force_update ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("SetRFIDCode")"; + } +- if (uic_mqtt_dotdot_door_lock_set_rfid_code_response_is_supported(unid, endpoint_id)) { ++ return false; ++} ++ ++// Publishing Supported Commands for Basic Cluster ++void uic_mqtt_dotdot_basic_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_basic_reset_to_factory_defaults_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("SetRFIDCodeResponse")"; ++ ss << R"("ResetToFactoryDefaults")"; + } +- if (uic_mqtt_dotdot_door_lock_get_rfid_code_is_supported(unid, endpoint_id)) { ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_basic_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetRFIDCode")"; ++ ss << R"("WriteAttributes")"; + } +- if (uic_mqtt_dotdot_door_lock_get_rfid_code_response_is_supported(unid, endpoint_id)) { ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_basic_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetRFIDCodeResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_rfid_code_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearRFIDCode")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_rfid_code_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearRFIDCodeResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearAllRFIDCodes")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearAllRFIDCodesResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_set_user_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetUser")"; +- } +- if (uic_mqtt_dotdot_door_lock_get_user_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetUser")"; +- } +- if (uic_mqtt_dotdot_door_lock_get_user_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetUserResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_user_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearUser")"; +- } +- if (uic_mqtt_dotdot_door_lock_operating_event_notification_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("OperatingEventNotification")"; +- } +- if (uic_mqtt_dotdot_door_lock_programming_event_notification_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ProgrammingEventNotification")"; +- } +- if (uic_mqtt_dotdot_door_lock_set_credential_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetCredential")"; +- } +- if (uic_mqtt_dotdot_door_lock_set_credential_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetCredentialResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_get_credential_status_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetCredentialStatus")"; +- } +- if (uic_mqtt_dotdot_door_lock_get_credential_status_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GetCredentialStatusResponse")"; +- } +- if (uic_mqtt_dotdot_door_lock_clear_credential_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ClearCredential")"; +- } +- if (uic_mqtt_dotdot_door_lock_unbolt_door_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UnboltDoor")"; +- } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_door_lock_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_door_lock_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ss << R"("ForceReadAttributes")"; + } + + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DoorLock/SupportedCommands"; ++ topic += "/Basic/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -101440,7 +100264,7 @@ void uic_mqtt_dotdot_door_lock_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/DoorLock/Attributes"; ++ attributes_topic += "/Basic/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101451,14 +100275,14 @@ void uic_mqtt_dotdot_door_lock_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for DoorLock Cluster +-void uic_mqtt_dotdot_door_lock_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Basic Cluster ++void uic_mqtt_dotdot_basic_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DoorLock/SupportedCommands"; ++ topic += "/Basic/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101468,10 +100292,10 @@ void uic_mqtt_dotdot_door_lock_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for WindowCovering Cluster +-void uic_mqtt_dotdot_window_covering_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for PowerConfiguration Cluster ++void uic_mqtt_dotdot_power_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/WindowCovering/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/PowerConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -101488,13 +100312,13 @@ void uic_mqtt_dotdot_window_covering_publish_cluster_revision(const char* base_t + true); + } + +-// Unretain Cluster Revision for WindowCovering Cluster +-void uic_mqtt_dotdot_window_covering_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for PowerConfiguration Cluster ++void uic_mqtt_dotdot_power_configuration_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/WindowCovering/Attributes/ClusterRevision"; ++ + "/PowerConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -101504,135 +100328,21 @@ void uic_mqtt_dotdot_window_covering_unretain_cluster_revision(const char* base_ + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_window_covering_up_or_open_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_window_covering_up_or_open_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_down_or_close_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_window_covering_down_or_close_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_stop_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_window_covering_stop_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_value_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t lift_value_value; +- memset(&lift_value_value, 0x00, sizeof(lift_value_value)); +- for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- lift_value_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_percentage_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t percentage_lift_value_value; +- memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); +- for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- percentage_lift_value_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_value_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t tilt_value_value; +- memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); +- for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- tilt_value_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t percentage_tilt_value_value; +- memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); +- for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- percentage_tilt_value_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} + +-static inline bool uic_mqtt_dotdot_window_covering_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_power_configuration_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_window_covering_write_attributes_callback) { +- uic_mqtt_dotdot_window_covering_state_t window_covering_new_state = {}; +- uic_mqtt_dotdot_window_covering_updated_state_t window_covering_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_power_configuration_write_attributes_callback) { ++ uic_mqtt_dotdot_power_configuration_state_t power_configuration_new_state = {}; ++ uic_mqtt_dotdot_power_configuration_updated_state_t power_configuration_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- window_covering_new_state, +- window_covering_new_updated_state ++ power_configuration_new_state, ++ power_configuration_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -101640,17 +100350,17 @@ static inline bool uic_mqtt_dotdot_window_covering_write_attributes_is_supported + return false; + } + +-static inline bool uic_mqtt_dotdot_window_covering_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_power_configuration_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_window_covering_force_read_attributes_callback) { +- uic_mqtt_dotdot_window_covering_updated_state_t window_covering_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_power_configuration_force_read_attributes_callback) { ++ uic_mqtt_dotdot_power_configuration_updated_state_t power_configuration_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- window_covering_force_update ++ power_configuration_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -101658,8 +100368,8 @@ static inline bool uic_mqtt_dotdot_window_covering_force_read_attributes_is_supp + return false; + } + +-// Publishing Supported Commands for WindowCovering Cluster +-void uic_mqtt_dotdot_window_covering_publish_supported_commands( ++// Publishing Supported Commands for PowerConfiguration Cluster ++void uic_mqtt_dotdot_power_configuration_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -101668,58 +100378,9 @@ void uic_mqtt_dotdot_window_covering_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_window_covering_up_or_open_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("UpOrOpen")"; +- } +- if (uic_mqtt_dotdot_window_covering_down_or_close_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("DownOrClose")"; +- } +- if (uic_mqtt_dotdot_window_covering_stop_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Stop")"; +- } +- if (uic_mqtt_dotdot_window_covering_go_to_lift_value_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GoToLiftValue")"; +- } +- if (uic_mqtt_dotdot_window_covering_go_to_lift_percentage_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GoToLiftPercentage")"; +- } +- if (uic_mqtt_dotdot_window_covering_go_to_tilt_value_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GoToTiltValue")"; +- } +- if (uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GoToTiltPercentage")"; +- } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_window_covering_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_power_configuration_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -101728,7 +100389,7 @@ void uic_mqtt_dotdot_window_covering_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_window_covering_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_power_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -101739,7 +100400,7 @@ void uic_mqtt_dotdot_window_covering_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/WindowCovering/SupportedCommands"; ++ topic += "/PowerConfiguration/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -101751,7 +100412,7 @@ void uic_mqtt_dotdot_window_covering_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/WindowCovering/Attributes"; ++ attributes_topic += "/PowerConfiguration/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101762,14 +100423,14 @@ void uic_mqtt_dotdot_window_covering_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for WindowCovering Cluster +-void uic_mqtt_dotdot_window_covering_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for PowerConfiguration Cluster ++void uic_mqtt_dotdot_power_configuration_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/WindowCovering/SupportedCommands"; ++ topic += "/PowerConfiguration/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101779,10 +100440,10 @@ void uic_mqtt_dotdot_window_covering_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for BarrierControl Cluster +-void uic_mqtt_dotdot_barrier_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for DeviceTemperatureConfiguration Cluster ++void uic_mqtt_dotdot_device_temperature_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/BarrierControl/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/DeviceTemperatureConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -101799,13 +100460,13 @@ void uic_mqtt_dotdot_barrier_control_publish_cluster_revision(const char* base_t + true); + } + +-// Unretain Cluster Revision for BarrierControl Cluster +-void uic_mqtt_dotdot_barrier_control_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for DeviceTemperatureConfiguration Cluster ++void uic_mqtt_dotdot_device_temperature_configuration_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/BarrierControl/Attributes/ClusterRevision"; ++ + "/DeviceTemperatureConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -101815,53 +100476,21 @@ void uic_mqtt_dotdot_barrier_control_unretain_cluster_revision(const char* base_ + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_barrier_control_go_to_percent_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t percent_open_value; +- memset(&percent_open_value, 0x00, sizeof(percent_open_value)); +- for (const auto& callback: uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- percent_open_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_barrier_control_stop_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_barrier_control_stop_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} + +-static inline bool uic_mqtt_dotdot_barrier_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_device_temperature_configuration_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_barrier_control_write_attributes_callback) { +- uic_mqtt_dotdot_barrier_control_state_t barrier_control_new_state = {}; +- uic_mqtt_dotdot_barrier_control_updated_state_t barrier_control_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_device_temperature_configuration_write_attributes_callback) { ++ uic_mqtt_dotdot_device_temperature_configuration_state_t device_temperature_configuration_new_state = {}; ++ uic_mqtt_dotdot_device_temperature_configuration_updated_state_t device_temperature_configuration_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- barrier_control_new_state, +- barrier_control_new_updated_state ++ device_temperature_configuration_new_state, ++ device_temperature_configuration_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -101869,17 +100498,17 @@ static inline bool uic_mqtt_dotdot_barrier_control_write_attributes_is_supported + return false; + } + +-static inline bool uic_mqtt_dotdot_barrier_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_barrier_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_barrier_control_updated_state_t barrier_control_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_callback) { ++ uic_mqtt_dotdot_device_temperature_configuration_updated_state_t device_temperature_configuration_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- barrier_control_force_update ++ device_temperature_configuration_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -101887,8 +100516,8 @@ static inline bool uic_mqtt_dotdot_barrier_control_force_read_attributes_is_supp + return false; + } + +-// Publishing Supported Commands for BarrierControl Cluster +-void uic_mqtt_dotdot_barrier_control_publish_supported_commands( ++// Publishing Supported Commands for DeviceTemperatureConfiguration Cluster ++void uic_mqtt_dotdot_device_temperature_configuration_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -101897,23 +100526,9 @@ void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_barrier_control_go_to_percent_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("GoToPercent")"; +- } +- if (uic_mqtt_dotdot_barrier_control_stop_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Stop")"; +- } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_barrier_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_device_temperature_configuration_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -101922,7 +100537,7 @@ void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_barrier_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_device_temperature_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -101933,7 +100548,7 @@ void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/BarrierControl/SupportedCommands"; ++ topic += "/DeviceTemperatureConfiguration/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -101945,7 +100560,7 @@ void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/BarrierControl/Attributes"; ++ attributes_topic += "/DeviceTemperatureConfiguration/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101956,14 +100571,14 @@ void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for BarrierControl Cluster +-void uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for DeviceTemperatureConfiguration Cluster ++void uic_mqtt_dotdot_device_temperature_configuration_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/BarrierControl/SupportedCommands"; ++ topic += "/DeviceTemperatureConfiguration/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -101973,10 +100588,10 @@ void uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for PumpConfigurationAndControl Cluster +-void uic_mqtt_dotdot_pump_configuration_and_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Identify Cluster ++void uic_mqtt_dotdot_identify_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/PumpConfigurationAndControl/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Identify/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -101993,13 +100608,13 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_cluster_revision(con + true); + } + +-// Unretain Cluster Revision for PumpConfigurationAndControl Cluster +-void uic_mqtt_dotdot_pump_configuration_and_control_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Identify Cluster ++void uic_mqtt_dotdot_identify_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/PumpConfigurationAndControl/Attributes/ClusterRevision"; ++ + "/Identify/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -102009,59 +100624,159 @@ void uic_mqtt_dotdot_pump_configuration_and_control_unretain_cluster_revision(co + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_identify_identify_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_callback) { +- uic_mqtt_dotdot_pump_configuration_and_control_state_t pump_configuration_and_control_new_state = {}; +- uic_mqtt_dotdot_pump_configuration_and_control_updated_state_t pump_configuration_and_control_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pump_configuration_and_control_new_state, +- pump_configuration_and_control_new_updated_state +- ) == SL_STATUS_OK) { ++ int16_t identify_time_value; ++ memset(&identify_time_value, 0x00, sizeof(identify_time_value)); ++ for (const auto& callback: uic_mqtt_dotdot_identify_identify_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ identify_time_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_identify_identify_query_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_pump_configuration_and_control_updated_state_t pump_configuration_and_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pump_configuration_and_control_force_update +- ) == SL_STATUS_OK) { ++ int16_t timeout_value; ++ memset(&timeout_value, 0x00, sizeof(timeout_value)); ++ for (const auto& callback: uic_mqtt_dotdot_identify_identify_query_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ timeout_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for PumpConfigurationAndControl Cluster +-void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_identify_identify_query_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); ++ for (const auto& callback: uic_mqtt_dotdot_identify_identify_query_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +- // check if there is callback for each command ++ return false; ++} ++static inline bool uic_mqtt_dotdot_identify_trigger_effect_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ TriggerEffectEffectIdentifier effect_identifier_value; ++ memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); ++ TriggerEffectEffectVariant effect_variant_value; ++ memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); ++ for (const auto& callback: uic_mqtt_dotdot_identify_trigger_effect_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ effect_identifier_value, ++ ++ effect_variant_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_identify_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_identify_write_attributes_callback) { ++ uic_mqtt_dotdot_identify_state_t identify_new_state = {}; ++ uic_mqtt_dotdot_identify_updated_state_t identify_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ identify_new_state, ++ identify_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_identify_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_identify_force_read_attributes_callback) { ++ uic_mqtt_dotdot_identify_updated_state_t identify_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ identify_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for Identify Cluster ++void uic_mqtt_dotdot_identify_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_identify_identify_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Identify")"; ++ } ++ if (uic_mqtt_dotdot_identify_identify_query_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("IdentifyQueryResponse")"; ++ } ++ if (uic_mqtt_dotdot_identify_identify_query_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("IdentifyQuery")"; ++ } ++ if (uic_mqtt_dotdot_identify_trigger_effect_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("TriggerEffect")"; ++ } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_identify_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -102070,7 +100785,7 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_identify_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -102081,7 +100796,7 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PumpConfigurationAndControl/SupportedCommands"; ++ topic += "/Identify/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -102093,7 +100808,7 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PumpConfigurationAndControl/Attributes"; ++ attributes_topic += "/Identify/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -102104,14 +100819,14 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for PumpConfigurationAndControl Cluster +-void uic_mqtt_dotdot_pump_configuration_and_control_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Identify Cluster ++void uic_mqtt_dotdot_identify_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PumpConfigurationAndControl/SupportedCommands"; ++ topic += "/Identify/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -102121,10 +100836,10 @@ void uic_mqtt_dotdot_pump_configuration_and_control_publish_empty_supported_comm + } + } + +-// Publishing Cluster Revision for Thermostat Cluster +-void uic_mqtt_dotdot_thermostat_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Groups Cluster ++void uic_mqtt_dotdot_groups_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/Thermostat/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Groups/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -102141,13 +100856,13 @@ void uic_mqtt_dotdot_thermostat_publish_cluster_revision(const char* base_topic, + true); + } + +-// Unretain Cluster Revision for Thermostat Cluster +-void uic_mqtt_dotdot_thermostat_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Groups Cluster ++void uic_mqtt_dotdot_groups_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/Thermostat/Attributes/ClusterRevision"; ++ + "/Groups/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -102157,20 +100872,20 @@ void uic_mqtt_dotdot_thermostat_unretain_cluster_revision(const char* base_topic + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_is_supported( ++static inline bool uic_mqtt_dotdot_groups_add_group_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- SetpointRaiseOrLowerMode mode_value; +- memset(&mode_value, 0x00, sizeof(mode_value)); +- int8_t amount_value; +- memset(&amount_value, 0x00, sizeof(amount_value)); +- for (const auto& callback: uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_callback) { ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ const char* group_name_value; ++ memset(&group_name_value, 0x00, sizeof(group_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_add_group_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- mode_value, ++ group_id_value, + +- amount_value ++ group_name_value + + ) == SL_STATUS_OK) { + return true; +@@ -102179,27 +100894,39 @@ static inline bool uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_is_support + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_is_supported( ++static inline bool uic_mqtt_dotdot_groups_add_group_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t number_of_transitions_value; +- memset(&number_of_transitions_value, 0x00, sizeof(number_of_transitions_value)); +- uint8_t day_of_week_value; +- memset(&day_of_week_value, 0x00, sizeof(day_of_week_value)); +- uint8_t mode_value; +- memset(&mode_value, 0x00, sizeof(mode_value)); +- for (const auto& callback: uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_callback) { ++ uint8_t status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_add_group_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- number_of_transitions_value, +- +- day_of_week_value, ++ status_value, + +- mode_value, ++ group_id_value + +- 0, nullptr ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + ++ return false; ++} ++static inline bool uic_mqtt_dotdot_groups_view_group_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_view_group_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ group_id_value ++ + ) == SL_STATUS_OK) { + return true; + } +@@ -102207,25 +100934,39 @@ static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_is_su + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_set_weekly_schedule_is_supported( ++static inline bool uic_mqtt_dotdot_groups_view_group_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t number_of_transitions_value; +- memset(&number_of_transitions_value, 0x00, sizeof(number_of_transitions_value)); +- uint8_t day_of_week_value; +- memset(&day_of_week_value, 0x00, sizeof(day_of_week_value)); +- uint8_t mode_value; +- memset(&mode_value, 0x00, sizeof(mode_value)); +- for (const auto& callback: uic_mqtt_dotdot_thermostat_set_weekly_schedule_callback) { ++ uint8_t status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ const char* group_name_value; ++ memset(&group_name_value, 0x00, sizeof(group_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_view_group_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- number_of_transitions_value, ++ status_value, + +- day_of_week_value, ++ group_id_value, + +- mode_value, ++ group_name_value + ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_groups_get_group_membership_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_groups_get_group_membership_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , + 0, nullptr + + ) == SL_STATUS_OK) { +@@ -102235,36 +100976,36 @@ static inline bool uic_mqtt_dotdot_thermostat_set_weekly_schedule_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_supported( ++static inline bool uic_mqtt_dotdot_groups_get_group_membership_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint16_t time_of_day_value; +- memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); +- uint8_t relay_status_value; +- memset(&relay_status_value, 0x00, sizeof(relay_status_value)); +- int16_t local_temperature_value; +- memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- uint8_t humidity_percentage_value; +- memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); +- int16_t set_point_value; +- memset(&set_point_value, 0x00, sizeof(set_point_value)); +- uint16_t unread_entries_value; +- memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); +- for (const auto& callback: uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { ++ int8_t capacity_value; ++ memset(&capacity_value, 0x00, sizeof(capacity_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- time_of_day_value, +- +- relay_status_value, +- +- local_temperature_value, +- +- humidity_percentage_value, +- +- set_point_value, ++ capacity_value, + +- unread_entries_value ++ 0, nullptr ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_groups_remove_group_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ group_id_value + + ) == SL_STATUS_OK) { + return true; +@@ -102273,20 +101014,20 @@ static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_s + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_is_supported( ++static inline bool uic_mqtt_dotdot_groups_remove_group_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t days_to_return_value; +- memset(&days_to_return_value, 0x00, sizeof(days_to_return_value)); +- uint8_t mode_to_return_value; +- memset(&mode_to_return_value, 0x00, sizeof(mode_to_return_value)); +- for (const auto& callback: uic_mqtt_dotdot_thermostat_get_weekly_schedule_callback) { ++ uint8_t status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- days_to_return_value, ++ status_value, + +- mode_to_return_value ++ group_id_value + + ) == SL_STATUS_OK) { + return true; +@@ -102295,11 +101036,11 @@ static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_clear_weekly_schedule_is_supported( ++static inline bool uic_mqtt_dotdot_groups_remove_all_groups_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_clear_weekly_schedule_callback) { ++ for (const auto& callback: uic_mqtt_dotdot_groups_remove_all_groups_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + + ) == SL_STATUS_OK) { +@@ -102309,12 +101050,20 @@ static inline bool uic_mqtt_dotdot_thermostat_clear_weekly_schedule_is_supported + + return false; + } +-static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_is_supported( ++static inline bool uic_mqtt_dotdot_groups_add_group_if_identifying_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_get_relay_status_log_callback) { ++ int16_t group_id_value; ++ memset(&group_id_value, 0x00, sizeof(group_id_value)); ++ const char* group_name_value; ++ memset(&group_name_value, 0x00, sizeof(group_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ group_id_value, ++ ++ group_name_value + + ) == SL_STATUS_OK) { + return true; +@@ -102324,20 +101073,20 @@ static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_thermostat_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_groups_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_write_attributes_callback) { +- uic_mqtt_dotdot_thermostat_state_t thermostat_new_state = {}; +- uic_mqtt_dotdot_thermostat_updated_state_t thermostat_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_groups_write_attributes_callback) { ++ uic_mqtt_dotdot_groups_state_t groups_new_state = {}; ++ uic_mqtt_dotdot_groups_updated_state_t groups_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- thermostat_new_state, +- thermostat_new_updated_state ++ groups_new_state, ++ groups_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -102345,17 +101094,17 @@ static inline bool uic_mqtt_dotdot_thermostat_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_thermostat_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_groups_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_force_read_attributes_callback) { +- uic_mqtt_dotdot_thermostat_updated_state_t thermostat_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_groups_force_read_attributes_callback) { ++ uic_mqtt_dotdot_groups_updated_state_t groups_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- thermostat_force_update ++ groups_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -102363,8 +101112,8 @@ static inline bool uic_mqtt_dotdot_thermostat_force_read_attributes_is_supported + return false; + } + +-// Publishing Supported Commands for Thermostat Cluster +-void uic_mqtt_dotdot_thermostat_publish_supported_commands( ++// Publishing Supported Commands for Groups Cluster ++void uic_mqtt_dotdot_groups_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -102373,58 +101122,79 @@ void uic_mqtt_dotdot_thermostat_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_add_group_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("SetpointRaiseOrLower")"; ++ ss << R"("AddGroup")"; + } +- if (uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_add_group_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetWeeklyScheduleResponse")"; ++ ss << R"("AddGroupResponse")"; + } +- if (uic_mqtt_dotdot_thermostat_set_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_view_group_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("SetWeeklySchedule")"; ++ ss << R"("ViewGroup")"; + } +- if (uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_view_group_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetRelayStatusLogResponse")"; ++ ss << R"("ViewGroupResponse")"; + } +- if (uic_mqtt_dotdot_thermostat_get_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_get_group_membership_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetWeeklySchedule")"; ++ ss << R"("GetGroupMembership")"; + } +- if (uic_mqtt_dotdot_thermostat_clear_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_get_group_membership_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("ClearWeeklySchedule")"; ++ ss << R"("GetGroupMembershipResponse")"; + } +- if (uic_mqtt_dotdot_thermostat_get_relay_status_log_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_remove_group_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetRelayStatusLog")"; ++ ss << R"("RemoveGroup")"; ++ } ++ if (uic_mqtt_dotdot_groups_remove_group_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("RemoveGroupResponse")"; ++ } ++ if (uic_mqtt_dotdot_groups_remove_all_groups_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("RemoveAllGroups")"; ++ } ++ if (uic_mqtt_dotdot_groups_add_group_if_identifying_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("AddGroupIfIdentifying")"; + } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_thermostat_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_groups_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -102433,7 +101203,7 @@ void uic_mqtt_dotdot_thermostat_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_thermostat_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_groups_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -102444,7 +101214,7 @@ void uic_mqtt_dotdot_thermostat_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Thermostat/SupportedCommands"; ++ topic += "/Groups/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -102456,7 +101226,7 @@ void uic_mqtt_dotdot_thermostat_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Thermostat/Attributes"; ++ attributes_topic += "/Groups/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -102467,14 +101237,14 @@ void uic_mqtt_dotdot_thermostat_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for Thermostat Cluster +-void uic_mqtt_dotdot_thermostat_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Groups Cluster ++void uic_mqtt_dotdot_groups_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Thermostat/SupportedCommands"; ++ topic += "/Groups/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -102484,10 +101254,10 @@ void uic_mqtt_dotdot_thermostat_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for FanControl Cluster +-void uic_mqtt_dotdot_fan_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Scenes Cluster ++void uic_mqtt_dotdot_scenes_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/FanControl/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Scenes/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -102504,13 +101274,13 @@ void uic_mqtt_dotdot_fan_control_publish_cluster_revision(const char* base_topic + true); + } + +-// Unretain Cluster Revision for FanControl Cluster +-void uic_mqtt_dotdot_fan_control_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Scenes Cluster ++void uic_mqtt_dotdot_scenes_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/FanControl/Attributes/ClusterRevision"; ++ + "/Scenes/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -102520,476 +101290,280 @@ void uic_mqtt_dotdot_fan_control_unretain_cluster_revision(const char* base_topi + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_fan_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_add_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_fan_control_write_attributes_callback) { +- uic_mqtt_dotdot_fan_control_state_t fan_control_new_state = {}; +- uic_mqtt_dotdot_fan_control_updated_state_t fan_control_new_updated_state = {}; ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t * scene_name_value; ++ memset(&scene_name_value, 0x00, sizeof(scene_name_value)); ++ int8_t transition_time100ms_value; ++ memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ groupid_value, ++ ++ sceneid_value, ++ ++ transition_time_value, ++ ++ scene_name_value, ++ ++ 0, nullptr, + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- fan_control_new_state, +- fan_control_new_updated_state +- ) == SL_STATUS_OK) { ++ transition_time100ms_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_fan_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_add_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_fan_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_fan_control_updated_state_t fan_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- fan_control_force_update +- ) == SL_STATUS_OK) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for FanControl Cluster +-void uic_mqtt_dotdot_fan_control_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_scenes_view_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_fan_control_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_fan_control_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_scenes_view_scene_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t * scene_name_value; ++ memset(&scene_name_value, 0x00, sizeof(scene_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ groupid_value, ++ ++ sceneid_value, ++ ++ transition_time_value, ++ ++ scene_name_value, ++ ++ 0, nullptr ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/FanControl/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/FanControl/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } +-} +- +-// Publishing empty/no Supported Commands for FanControl Cluster +-void uic_mqtt_dotdot_fan_control_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/FanControl/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} +- +-// Publishing Cluster Revision for DehumidificationControl Cluster +-void uic_mqtt_dotdot_dehumidification_control_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/DehumidificationControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} +- +-// Unretain Cluster Revision for DehumidificationControl Cluster +-void uic_mqtt_dotdot_dehumidification_control_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/DehumidificationControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return false; + } +- +- +-static inline bool uic_mqtt_dotdot_dehumidification_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_remove_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_dehumidification_control_write_attributes_callback) { +- uic_mqtt_dotdot_dehumidification_control_state_t dehumidification_control_new_state = {}; +- uic_mqtt_dotdot_dehumidification_control_updated_state_t dehumidification_control_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- dehumidification_control_new_state, +- dehumidification_control_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_dehumidification_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_remove_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_dehumidification_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_dehumidification_control_updated_state_t dehumidification_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- dehumidification_control_force_update +- ) == SL_STATUS_OK) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for DehumidificationControl Cluster +-void uic_mqtt_dotdot_dehumidification_control_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_dehumidification_control_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_dehumidification_control_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DehumidificationControl/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/DehumidificationControl/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ groupid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} +- +-// Publishing empty/no Supported Commands for DehumidificationControl Cluster +-void uic_mqtt_dotdot_dehumidification_control_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/DehumidificationControl/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} +- +-// Publishing Cluster Revision for ThermostatUserInterfaceConfiguration Cluster +-void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/ThermostatUserInterfaceConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for ThermostatUserInterfaceConfiguration Cluster +-void uic_mqtt_dotdot_thermostat_user_interface_configuration_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/ThermostatUserInterfaceConfiguration/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return false; + } +- +- +-static inline bool uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_callback) { +- uic_mqtt_dotdot_thermostat_user_interface_configuration_state_t thermostat_user_interface_configuration_new_state = {}; +- uic_mqtt_dotdot_thermostat_user_interface_configuration_updated_state_t thermostat_user_interface_configuration_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- thermostat_user_interface_configuration_new_state, +- thermostat_user_interface_configuration_new_updated_state +- ) == SL_STATUS_OK) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ groupid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_store_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_callback) { +- uic_mqtt_dotdot_thermostat_user_interface_configuration_updated_state_t thermostat_user_interface_configuration_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- thermostat_user_interface_configuration_force_update +- ) == SL_STATUS_OK) { ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for ThermostatUserInterfaceConfiguration Cluster +-void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_scenes_store_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ThermostatUserInterfaceConfiguration/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ThermostatUserInterfaceConfiguration/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ groupid_value, ++ ++ sceneid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} +- +-// Publishing empty/no Supported Commands for ThermostatUserInterfaceConfiguration Cluster +-void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ThermostatUserInterfaceConfiguration/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} +- +-// Publishing Cluster Revision for ColorControl Cluster +-void uic_mqtt_dotdot_color_control_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/ColorControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for ColorControl Cluster +-void uic_mqtt_dotdot_color_control_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/ColorControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return false; + } +- +-static inline bool uic_mqtt_dotdot_color_control_move_to_hue_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_recall_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t hue_value; +- memset(&hue_value, 0x00, sizeof(hue_value)); +- CCDirection direction_value; +- memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_hue_callback) { ++ for (const auto& callback: uic_mqtt_dotdot_scenes_recall_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- hue_value, +- +- direction_value, +- +- transition_time_value, ++ groupid_value, + +- options_mask_value, ++ sceneid_value, + +- options_override_value ++ transition_time_value + + ) == SL_STATUS_OK) { + return true; +@@ -102998,28 +101572,16 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_hue_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_move_hue_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCMoveMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_hue_callback) { ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- move_mode_value, +- +- rate_value, +- +- options_mask_value, +- +- options_override_value ++ groupid_value + + ) == SL_STATUS_OK) { + return true; +@@ -103028,33 +101590,27 @@ static inline bool uic_mqtt_dotdot_color_control_move_hue_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_step_hue_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_step_hue_callback) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int8_t capacity_value; ++ memset(&capacity_value, 0x00, sizeof(capacity_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, ++ status_value, + +- options_mask_value, ++ capacity_value, + +- options_override_value ++ groupid_value, + ++ 0, nullptr ++ + ) == SL_STATUS_OK) { + return true; + } +@@ -103062,29 +101618,31 @@ static inline bool uic_mqtt_dotdot_color_control_step_hue_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_move_to_saturation_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t saturation_value; +- memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_saturation_callback) { ++ uint8_t * scene_name_value; ++ memset(&scene_name_value, 0x00, sizeof(scene_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- saturation_value, ++ groupid_value, + +- transition_time_value, ++ sceneid_value, + +- options_mask_value, ++ transition_time_value, + +- options_override_value ++ scene_name_value, + ++ 0, nullptr ++ + ) == SL_STATUS_OK) { + return true; + } +@@ -103092,258 +101650,24 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_saturation_is_supported + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_move_saturation_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCMoveMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_saturation_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- move_mode_value, +- +- rate_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_step_saturation_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- CCStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_step_saturation_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t hue_value; +- memset(&hue_value, 0x00, sizeof(hue_value)); +- uint8_t saturation_value; +- memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- hue_value, +- +- saturation_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_move_to_color_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t colorx_value; +- memset(&colorx_value, 0x00, sizeof(colorx_value)); +- uint16_t colory_value; +- memset(&colory_value, 0x00, sizeof(colory_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_color_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- colorx_value, +- +- colory_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_move_color_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- int16_t ratex_value; +- memset(&ratex_value, 0x00, sizeof(ratex_value)); +- int16_t ratey_value; +- memset(&ratey_value, 0x00, sizeof(ratey_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_color_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- ratex_value, +- +- ratey_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_step_color_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- int16_t stepx_value; +- memset(&stepx_value, 0x00, sizeof(stepx_value)); +- int16_t stepy_value; +- memset(&stepy_value, 0x00, sizeof(stepy_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_step_color_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- stepx_value, +- +- stepy_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_move_to_color_temperature_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t color_temperature_mireds_value; +- memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- color_temperature_mireds_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t enhanced_hue_value; +- memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- CCDirection direction_value; +- memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- enhanced_hue_value, +- +- direction_value, +- +- transition_time_value, ++ status_value, + +- options_mask_value, ++ groupid_value, + +- options_override_value ++ sceneid_value + + ) == SL_STATUS_OK) { + return true; +@@ -103352,28 +101676,20 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_support + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCMoveMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_hue_callback) { ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- move_mode_value, +- +- rate_value, +- +- options_mask_value, ++ groupid_value, + +- options_override_value ++ sceneid_value + + ) == SL_STATUS_OK) { + return true; +@@ -103382,131 +101698,35 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_enhanced_step_hue_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * groupid_value; ++ memset(&groupid_value, 0x00, sizeof(groupid_value)); ++ int8_t sceneid_value; ++ memset(&sceneid_value, 0x00, sizeof(sceneid_value)); ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_step_hue_callback) { ++ uint8_t * scene_name_value; ++ memset(&scene_name_value, 0x00, sizeof(scene_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, +- +- options_mask_value, +- +- options_override_value ++ status_value, + +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t enhanced_hue_value; +- memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- uint8_t saturation_value; +- memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- enhanced_hue_value, ++ groupid_value, + +- saturation_value, ++ sceneid_value, + + transition_time_value, + +- options_mask_value, +- +- options_override_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_color_loop_set_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t update_flags_value; +- memset(&update_flags_value, 0x00, sizeof(update_flags_value)); +- ColorLoopSetAction action_value; +- memset(&action_value, 0x00, sizeof(action_value)); +- CCColorLoopDirection direction_value; +- memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t time_value; +- memset(&time_value, 0x00, sizeof(time_value)); +- uint16_t start_hue_value; +- memset(&start_hue_value, 0x00, sizeof(start_hue_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_color_loop_set_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- update_flags_value, +- +- action_value, +- +- direction_value, +- +- time_value, +- +- start_hue_value, +- +- options_mask_value, +- +- options_override_value ++ scene_name_value, + +- ) == SL_STATUS_OK) { +- return true; +- } +- } ++ 0, nullptr + +- return false; +-} +-static inline bool uic_mqtt_dotdot_color_control_stop_move_step_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_stop_move_step_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- options_mask_value, +- +- options_override_value +- + ) == SL_STATUS_OK) { + return true; + } +@@ -103514,36 +101734,32 @@ static inline bool uic_mqtt_dotdot_color_control_stop_move_step_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_move_color_temperature_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_copy_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCMoveMode move_mode_value; +- memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; +- memset(&rate_value, 0x00, sizeof(rate_value)); +- uint16_t color_temperature_minimum_mireds_value; +- memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; +- memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_move_color_temperature_callback) { ++ uint8_t mode_value; ++ memset(&mode_value, 0x00, sizeof(mode_value)); ++ uint8_t * group_identifier_from_value; ++ memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); ++ int8_t scene_identifier_from_value; ++ memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); ++ uint8_t * group_identifier_to_value; ++ memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); ++ int8_t scene_identifier_to_value; ++ memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- move_mode_value, +- +- rate_value, ++ mode_value, + +- color_temperature_minimum_mireds_value, ++ group_identifier_from_value, + +- color_temperature_maximum_mireds_value, ++ scene_identifier_from_value, + +- options_mask_value, ++ group_identifier_to_value, + +- options_override_value ++ scene_identifier_to_value + + ) == SL_STATUS_OK) { + return true; +@@ -103552,40 +101768,24 @@ static inline bool uic_mqtt_dotdot_color_control_move_color_temperature_is_suppo + + return false; + } +-static inline bool uic_mqtt_dotdot_color_control_step_color_temperature_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_copy_scene_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- CCStepMode step_mode_value; +- memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; +- memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; +- memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint16_t color_temperature_minimum_mireds_value; +- memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; +- memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); +- uint8_t options_mask_value; +- memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +- uint8_t options_override_value; +- memset(&options_override_value, 0x00, sizeof(options_override_value)); +- for (const auto& callback: uic_mqtt_dotdot_color_control_step_color_temperature_callback) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t * group_identifier_from_value; ++ memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); ++ int8_t scene_identifier_from_value; ++ memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); ++ for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- step_mode_value, +- +- step_size_value, +- +- transition_time_value, +- +- color_temperature_minimum_mireds_value, +- +- color_temperature_maximum_mireds_value, ++ status_value, + +- options_mask_value, ++ group_identifier_from_value, + +- options_override_value ++ scene_identifier_from_value + + ) == SL_STATUS_OK) { + return true; +@@ -103595,20 +101795,20 @@ static inline bool uic_mqtt_dotdot_color_control_step_color_temperature_is_suppo + return false; + } + +-static inline bool uic_mqtt_dotdot_color_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_color_control_write_attributes_callback) { +- uic_mqtt_dotdot_color_control_state_t color_control_new_state = {}; +- uic_mqtt_dotdot_color_control_updated_state_t color_control_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_scenes_write_attributes_callback) { ++ uic_mqtt_dotdot_scenes_state_t scenes_new_state = {}; ++ uic_mqtt_dotdot_scenes_updated_state_t scenes_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- color_control_new_state, +- color_control_new_updated_state ++ scenes_new_state, ++ scenes_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -103616,17 +101816,17 @@ static inline bool uic_mqtt_dotdot_color_control_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_color_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_scenes_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_color_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_color_control_updated_state_t color_control_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_scenes_force_read_attributes_callback) { ++ uic_mqtt_dotdot_scenes_updated_state_t scenes_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- color_control_force_update ++ scenes_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -103634,8 +101834,8 @@ static inline bool uic_mqtt_dotdot_color_control_force_read_attributes_is_suppor + return false; + } + +-// Publishing Supported Commands for ColorControl Cluster +-void uic_mqtt_dotdot_color_control_publish_supported_commands( ++// Publishing Supported Commands for Scenes Cluster ++void uic_mqtt_dotdot_scenes_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -103644,142 +101844,142 @@ void uic_mqtt_dotdot_color_control_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_color_control_move_to_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_add_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveToHue")"; ++ ss << R"("AddScene")"; + } +- if (uic_mqtt_dotdot_color_control_move_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_add_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveHue")"; ++ ss << R"("AddSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_step_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_view_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("StepHue")"; ++ ss << R"("ViewScene")"; + } +- if (uic_mqtt_dotdot_color_control_move_to_saturation_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_view_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveToSaturation")"; ++ ss << R"("ViewSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_move_saturation_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_remove_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveSaturation")"; ++ ss << R"("RemoveScene")"; + } +- if (uic_mqtt_dotdot_color_control_step_saturation_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_remove_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("StepSaturation")"; ++ ss << R"("RemoveSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_remove_all_scenes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveToHueAndSaturation")"; ++ ss << R"("RemoveAllScenes")"; + } +- if (uic_mqtt_dotdot_color_control_move_to_color_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_remove_all_scenes_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveToColor")"; ++ ss << R"("RemoveAllScenesResponse")"; + } +- if (uic_mqtt_dotdot_color_control_move_color_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_store_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveColor")"; ++ ss << R"("StoreScene")"; + } +- if (uic_mqtt_dotdot_color_control_step_color_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_store_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("StepColor")"; ++ ss << R"("StoreSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_move_to_color_temperature_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_recall_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveToColorTemperature")"; ++ ss << R"("RecallScene")"; + } +- if (uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_get_scene_membership_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("EnhancedMoveToHue")"; ++ ss << R"("GetSceneMembership")"; + } +- if (uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_get_scene_membership_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("EnhancedMoveHue")"; ++ ss << R"("GetSceneMembershipResponse")"; + } +- if (uic_mqtt_dotdot_color_control_enhanced_step_hue_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_enhanced_add_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("EnhancedStepHue")"; ++ ss << R"("EnhancedAddScene")"; + } +- if (uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_enhanced_add_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("EnhancedMoveToHueAndSaturation")"; ++ ss << R"("EnhancedAddSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_color_loop_set_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_enhanced_view_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("ColorLoopSet")"; ++ ss << R"("EnhancedViewScene")"; + } +- if (uic_mqtt_dotdot_color_control_stop_move_step_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_enhanced_view_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("StopMoveStep")"; ++ ss << R"("EnhancedViewSceneResponse")"; + } +- if (uic_mqtt_dotdot_color_control_move_color_temperature_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_copy_scene_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("MoveColorTemperature")"; ++ ss << R"("CopyScene")"; + } +- if (uic_mqtt_dotdot_color_control_step_color_temperature_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_copy_scene_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("StepColorTemperature")"; ++ ss << R"("CopySceneResponse")"; + } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_color_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_scenes_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -103788,7 +101988,7 @@ void uic_mqtt_dotdot_color_control_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_color_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_scenes_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -103799,7 +101999,7 @@ void uic_mqtt_dotdot_color_control_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ColorControl/SupportedCommands"; ++ topic += "/Scenes/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -103811,7 +102011,7 @@ void uic_mqtt_dotdot_color_control_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ColorControl/Attributes"; ++ attributes_topic += "/Scenes/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -103822,14 +102022,14 @@ void uic_mqtt_dotdot_color_control_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for ColorControl Cluster +-void uic_mqtt_dotdot_color_control_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Scenes Cluster ++void uic_mqtt_dotdot_scenes_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ColorControl/SupportedCommands"; ++ topic += "/Scenes/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -103839,10 +102039,10 @@ void uic_mqtt_dotdot_color_control_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for BallastConfiguration Cluster +-void uic_mqtt_dotdot_ballast_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for OnOff Cluster ++void uic_mqtt_dotdot_on_off_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/BallastConfiguration/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/OnOff/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -103859,13 +102059,13 @@ void uic_mqtt_dotdot_ballast_configuration_publish_cluster_revision(const char* + true); + } + +-// Unretain Cluster Revision for BallastConfiguration Cluster +-void uic_mqtt_dotdot_ballast_configuration_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for OnOff Cluster ++void uic_mqtt_dotdot_on_off_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/BallastConfiguration/Attributes/ClusterRevision"; ++ + "/OnOff/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -103875,169 +102075,125 @@ void uic_mqtt_dotdot_ballast_configuration_unretain_cluster_revision(const char* + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_ballast_configuration_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_on_off_off_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ballast_configuration_write_attributes_callback) { +- uic_mqtt_dotdot_ballast_configuration_state_t ballast_configuration_new_state = {}; +- uic_mqtt_dotdot_ballast_configuration_updated_state_t ballast_configuration_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ballast_configuration_new_state, +- ballast_configuration_new_updated_state +- ) == SL_STATUS_OK) { ++ for (const auto& callback: uic_mqtt_dotdot_on_off_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_ballast_configuration_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_on_off_on_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ballast_configuration_force_read_attributes_callback) { +- uic_mqtt_dotdot_ballast_configuration_updated_state_t ballast_configuration_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ballast_configuration_force_update +- ) == SL_STATUS_OK) { ++ for (const auto& callback: uic_mqtt_dotdot_on_off_on_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for BallastConfiguration Cluster +-void uic_mqtt_dotdot_ballast_configuration_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_on_off_toggle_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_ballast_configuration_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ for (const auto& callback: uic_mqtt_dotdot_on_off_toggle_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_ballast_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_on_off_off_with_effect_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ OffWithEffectEffectIdentifier effect_identifier_value; ++ memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); ++ int8_t effect_variant_value; ++ memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); ++ for (const auto& callback: uic_mqtt_dotdot_on_off_off_with_effect_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ effect_identifier_value, ++ ++ effect_variant_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/BallastConfiguration/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/BallastConfiguration/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for BallastConfiguration Cluster +-void uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_on_off_on_with_recall_global_scene_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/BallastConfiguration/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ for (const auto& callback: uic_mqtt_dotdot_on_off_on_with_recall_global_scene_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for IlluminanceMeasurement Cluster +-void uic_mqtt_dotdot_illuminance_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/IlluminanceMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for IlluminanceMeasurement Cluster +-void uic_mqtt_dotdot_illuminance_measurement_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_on_off_on_with_timed_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/IlluminanceMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} ++ uint8_t on_off_control_value; ++ memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); ++ int16_t on_time_value; ++ memset(&on_time_value, 0x00, sizeof(on_time_value)); ++ int16_t off_wait_time_value; ++ memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); ++ for (const auto& callback: uic_mqtt_dotdot_on_off_on_with_timed_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ on_off_control_value, ++ ++ on_time_value, ++ ++ off_wait_time_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + ++ return false; ++} + +-static inline bool uic_mqtt_dotdot_illuminance_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_on_off_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_illuminance_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_illuminance_measurement_state_t illuminance_measurement_new_state = {}; +- uic_mqtt_dotdot_illuminance_measurement_updated_state_t illuminance_measurement_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_on_off_write_attributes_callback) { ++ uic_mqtt_dotdot_on_off_state_t on_off_new_state = {}; ++ uic_mqtt_dotdot_on_off_updated_state_t on_off_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- illuminance_measurement_new_state, +- illuminance_measurement_new_updated_state ++ on_off_new_state, ++ on_off_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -104045,17 +102201,17 @@ static inline bool uic_mqtt_dotdot_illuminance_measurement_write_attributes_is_s + return false; + } + +-static inline bool uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_on_off_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_illuminance_measurement_updated_state_t illuminance_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_on_off_force_read_attributes_callback) { ++ uic_mqtt_dotdot_on_off_updated_state_t on_off_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- illuminance_measurement_force_update ++ on_off_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -104063,8 +102219,8 @@ static inline bool uic_mqtt_dotdot_illuminance_measurement_force_read_attributes + return false; + } + +-// Publishing Supported Commands for IlluminanceMeasurement Cluster +-void uic_mqtt_dotdot_illuminance_measurement_publish_supported_commands( ++// Publishing Supported Commands for OnOff Cluster ++void uic_mqtt_dotdot_on_off_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -104073,157 +102229,51 @@ void uic_mqtt_dotdot_illuminance_measurement_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_illuminance_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_on_off_off_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("WriteAttributes")"; ++ ss << R"("Off")"; + } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_on_off_on_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ss << R"("On")"; + } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IlluminanceMeasurement/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/IlluminanceMeasurement/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_on_off_toggle_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("Toggle")"; + } +-} +- +-// Publishing empty/no Supported Commands for IlluminanceMeasurement Cluster +-void uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IlluminanceMeasurement/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_on_off_off_with_effect_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("OffWithEffect")"; + } +-} +- +-// Publishing Cluster Revision for IlluminanceLevelSensing Cluster +-void uic_mqtt_dotdot_illuminance_level_sensing_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/IlluminanceLevelSensing/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} +- +-// Unretain Cluster Revision for IlluminanceLevelSensing Cluster +-void uic_mqtt_dotdot_illuminance_level_sensing_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/IlluminanceLevelSensing/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- +- +-static inline bool uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_callback) { +- uic_mqtt_dotdot_illuminance_level_sensing_state_t illuminance_level_sensing_new_state = {}; +- uic_mqtt_dotdot_illuminance_level_sensing_updated_state_t illuminance_level_sensing_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- illuminance_level_sensing_new_state, +- illuminance_level_sensing_new_updated_state +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_on_off_on_with_recall_global_scene_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("OnWithRecallGlobalScene")"; + } +- return false; +-} +- +-static inline bool uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_callback) { +- uic_mqtt_dotdot_illuminance_level_sensing_updated_state_t illuminance_level_sensing_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- illuminance_level_sensing_force_update +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_on_off_on_with_timed_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("OnWithTimedOff")"; + } +- return false; +-} +- +-// Publishing Supported Commands for IlluminanceLevelSensing Cluster +-void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_on_off_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104232,7 +102282,7 @@ void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_on_off_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104243,7 +102293,7 @@ void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IlluminanceLevelSensing/SupportedCommands"; ++ topic += "/OnOff/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -104255,7 +102305,7 @@ void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/IlluminanceLevelSensing/Attributes"; ++ attributes_topic += "/OnOff/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104266,14 +102316,14 @@ void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for IlluminanceLevelSensing Cluster +-void uic_mqtt_dotdot_illuminance_level_sensing_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for OnOff Cluster ++void uic_mqtt_dotdot_on_off_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IlluminanceLevelSensing/SupportedCommands"; ++ topic += "/OnOff/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104283,10 +102333,10 @@ void uic_mqtt_dotdot_illuminance_level_sensing_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for TemperatureMeasurement Cluster +-void uic_mqtt_dotdot_temperature_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Level Cluster ++void uic_mqtt_dotdot_level_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/TemperatureMeasurement/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Level/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -104303,13 +102353,13 @@ void uic_mqtt_dotdot_temperature_measurement_publish_cluster_revision(const char + true); + } + +-// Unretain Cluster Revision for TemperatureMeasurement Cluster +-void uic_mqtt_dotdot_temperature_measurement_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Level Cluster ++void uic_mqtt_dotdot_level_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/TemperatureMeasurement/Attributes/ClusterRevision"; ++ + "/Level/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -104319,169 +102369,271 @@ void uic_mqtt_dotdot_temperature_measurement_unretain_cluster_revision(const cha + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_temperature_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_level_move_to_level_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_temperature_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_temperature_measurement_state_t temperature_measurement_new_state = {}; +- uic_mqtt_dotdot_temperature_measurement_updated_state_t temperature_measurement_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- temperature_measurement_new_state, +- temperature_measurement_new_updated_state +- ) == SL_STATUS_OK) { ++ int8_t level_value; ++ memset(&level_value, 0x00, sizeof(level_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_move_to_level_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ level_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_temperature_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_level_move_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_temperature_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_temperature_measurement_updated_state_t temperature_measurement_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- temperature_measurement_force_update +- ) == SL_STATUS_OK) { ++ MoveStepMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int8_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_move_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for TemperatureMeasurement Cluster +-void uic_mqtt_dotdot_temperature_measurement_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_level_step_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_temperature_measurement_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; ++ MoveStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int8_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_step_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_temperature_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_level_stop_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_stop_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/TemperatureMeasurement/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/TemperatureMeasurement/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ return false; ++} ++static inline bool uic_mqtt_dotdot_level_move_to_level_with_on_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int8_t level_value; ++ memset(&level_value, 0x00, sizeof(level_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ level_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} + +-// Publishing empty/no Supported Commands for TemperatureMeasurement Cluster +-void uic_mqtt_dotdot_temperature_measurement_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_level_move_with_on_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/TemperatureMeasurement/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ MoveStepMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int8_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_move_with_on_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for PressureMeasurement Cluster +-void uic_mqtt_dotdot_pressure_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/PressureMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } ++static inline bool uic_mqtt_dotdot_level_step_with_on_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ MoveStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int8_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_step_with_on_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-// Unretain Cluster Revision for PressureMeasurement Cluster +-void uic_mqtt_dotdot_pressure_measurement_unretain_cluster_revision(const char* base_topic) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_level_stop_with_on_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/PressureMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_stop_with_on_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; + } ++static inline bool uic_mqtt_dotdot_level_move_to_closest_frequency_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t frequency_value; ++ memset(&frequency_value, 0x00, sizeof(frequency_value)); ++ for (const auto& callback: uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ frequency_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + ++ return false; ++} + +-static inline bool uic_mqtt_dotdot_pressure_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_level_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pressure_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_pressure_measurement_state_t pressure_measurement_new_state = {}; +- uic_mqtt_dotdot_pressure_measurement_updated_state_t pressure_measurement_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_level_write_attributes_callback) { ++ uic_mqtt_dotdot_level_state_t level_new_state = {}; ++ uic_mqtt_dotdot_level_updated_state_t level_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pressure_measurement_new_state, +- pressure_measurement_new_updated_state ++ level_new_state, ++ level_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -104489,17 +102641,17 @@ static inline bool uic_mqtt_dotdot_pressure_measurement_write_attributes_is_supp + return false; + } + +-static inline bool uic_mqtt_dotdot_pressure_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_level_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pressure_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_pressure_measurement_updated_state_t pressure_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_level_force_read_attributes_callback) { ++ uic_mqtt_dotdot_level_updated_state_t level_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pressure_measurement_force_update ++ level_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -104507,8 +102659,8 @@ static inline bool uic_mqtt_dotdot_pressure_measurement_force_read_attributes_is + return false; + } + +-// Publishing Supported Commands for PressureMeasurement Cluster +-void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( ++// Publishing Supported Commands for Level Cluster ++void uic_mqtt_dotdot_level_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -104517,9 +102669,72 @@ void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command ++ if (uic_mqtt_dotdot_level_move_to_level_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToLevel")"; ++ } ++ if (uic_mqtt_dotdot_level_move_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Move")"; ++ } ++ if (uic_mqtt_dotdot_level_step_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Step")"; ++ } ++ if (uic_mqtt_dotdot_level_stop_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Stop")"; ++ } ++ if (uic_mqtt_dotdot_level_move_to_level_with_on_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToLevelWithOnOff")"; ++ } ++ if (uic_mqtt_dotdot_level_move_with_on_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveWithOnOff")"; ++ } ++ if (uic_mqtt_dotdot_level_step_with_on_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StepWithOnOff")"; ++ } ++ if (uic_mqtt_dotdot_level_stop_with_on_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StopWithOnOff")"; ++ } ++ if (uic_mqtt_dotdot_level_move_to_closest_frequency_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToClosestFrequency")"; ++ } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_pressure_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_level_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104528,7 +102743,7 @@ void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_pressure_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_level_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104539,7 +102754,7 @@ void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PressureMeasurement/SupportedCommands"; ++ topic += "/Level/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -104551,7 +102766,7 @@ void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PressureMeasurement/Attributes"; ++ attributes_topic += "/Level/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104562,14 +102777,14 @@ void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for PressureMeasurement Cluster +-void uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Level Cluster ++void uic_mqtt_dotdot_level_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PressureMeasurement/SupportedCommands"; ++ topic += "/Level/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104579,10 +102794,10 @@ void uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for FlowMeasurement Cluster +-void uic_mqtt_dotdot_flow_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Alarms Cluster ++void uic_mqtt_dotdot_alarms_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/FlowMeasurement/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Alarms/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -104599,13 +102814,13 @@ void uic_mqtt_dotdot_flow_measurement_publish_cluster_revision(const char* base_ + true); + } + +-// Unretain Cluster Revision for FlowMeasurement Cluster +-void uic_mqtt_dotdot_flow_measurement_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Alarms Cluster ++void uic_mqtt_dotdot_alarms_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/FlowMeasurement/Attributes/ClusterRevision"; ++ + "/Alarms/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -104615,21 +102830,137 @@ void uic_mqtt_dotdot_flow_measurement_unretain_cluster_revision(const char* base + // clang-format off + } + ++static inline bool uic_mqtt_dotdot_alarms_reset_alarm_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t alarm_code_value; ++ memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); ++ uint8_t cluster_identifier_value; ++ memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); ++ for (const auto& callback: uic_mqtt_dotdot_alarms_reset_alarm_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ alarm_code_value, ++ ++ cluster_identifier_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_flow_measurement_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_alarms_alarm_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_flow_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_flow_measurement_state_t flow_measurement_new_state = {}; +- uic_mqtt_dotdot_flow_measurement_updated_state_t flow_measurement_new_updated_state = {}; ++ uint8_t alarm_code_value; ++ memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); ++ uint8_t cluster_identifier_value; ++ memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); ++ for (const auto& callback: uic_mqtt_dotdot_alarms_alarm_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ alarm_code_value, ++ ++ cluster_identifier_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_alarms_reset_all_alarms_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_alarms_reset_all_alarms_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_alarms_get_alarm_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t alarm_code_value; ++ memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); ++ uint8_t cluster_identifier_value; ++ memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); ++ int32_t time_stamp_value; ++ memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); ++ for (const auto& callback: uic_mqtt_dotdot_alarms_get_alarm_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value, ++ ++ alarm_code_value, ++ ++ cluster_identifier_value, ++ ++ time_stamp_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_alarms_get_alarm_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_alarms_get_alarm_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_alarms_reset_alarm_log_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_alarms_reset_alarm_log_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_alarms_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_alarms_write_attributes_callback) { ++ uic_mqtt_dotdot_alarms_state_t alarms_new_state = {}; ++ uic_mqtt_dotdot_alarms_updated_state_t alarms_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- flow_measurement_new_state, +- flow_measurement_new_updated_state ++ alarms_new_state, ++ alarms_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -104637,17 +102968,17 @@ static inline bool uic_mqtt_dotdot_flow_measurement_write_attributes_is_supporte + return false; + } + +-static inline bool uic_mqtt_dotdot_flow_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_alarms_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_flow_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_flow_measurement_updated_state_t flow_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_alarms_force_read_attributes_callback) { ++ uic_mqtt_dotdot_alarms_updated_state_t alarms_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- flow_measurement_force_update ++ alarms_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -104655,8 +102986,8 @@ static inline bool uic_mqtt_dotdot_flow_measurement_force_read_attributes_is_sup + return false; + } + +-// Publishing Supported Commands for FlowMeasurement Cluster +-void uic_mqtt_dotdot_flow_measurement_publish_supported_commands( ++// Publishing Supported Commands for Alarms Cluster ++void uic_mqtt_dotdot_alarms_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -104665,157 +102996,51 @@ void uic_mqtt_dotdot_flow_measurement_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_flow_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_alarms_reset_alarm_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("WriteAttributes")"; ++ ss << R"("ResetAlarm")"; + } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_flow_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_alarms_alarm_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ss << R"("Alarm")"; + } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/FlowMeasurement/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/FlowMeasurement/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_alarms_reset_all_alarms_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("ResetAllAlarms")"; + } +-} +- +-// Publishing empty/no Supported Commands for FlowMeasurement Cluster +-void uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/FlowMeasurement/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_alarms_get_alarm_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetAlarmResponse")"; + } +-} +- +-// Publishing Cluster Revision for RelativityHumidity Cluster +-void uic_mqtt_dotdot_relativity_humidity_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/RelativityHumidity/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} +- +-// Unretain Cluster Revision for RelativityHumidity Cluster +-void uic_mqtt_dotdot_relativity_humidity_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/RelativityHumidity/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- +- +-static inline bool uic_mqtt_dotdot_relativity_humidity_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_relativity_humidity_write_attributes_callback) { +- uic_mqtt_dotdot_relativity_humidity_state_t relativity_humidity_new_state = {}; +- uic_mqtt_dotdot_relativity_humidity_updated_state_t relativity_humidity_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- relativity_humidity_new_state, +- relativity_humidity_new_updated_state +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_alarms_get_alarm_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("GetAlarm")"; + } +- return false; +-} +- +-static inline bool uic_mqtt_dotdot_relativity_humidity_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_relativity_humidity_force_read_attributes_callback) { +- uic_mqtt_dotdot_relativity_humidity_updated_state_t relativity_humidity_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- relativity_humidity_force_update +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_alarms_reset_alarm_log_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("ResetAlarmLog")"; + } +- return false; +-} +- +-// Publishing Supported Commands for RelativityHumidity Cluster +-void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_relativity_humidity_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_alarms_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104824,7 +103049,7 @@ void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_relativity_humidity_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_alarms_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104835,7 +103060,7 @@ void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/RelativityHumidity/SupportedCommands"; ++ topic += "/Alarms/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -104847,7 +103072,7 @@ void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/RelativityHumidity/Attributes"; ++ attributes_topic += "/Alarms/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104858,14 +103083,14 @@ void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for RelativityHumidity Cluster +-void uic_mqtt_dotdot_relativity_humidity_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Alarms Cluster ++void uic_mqtt_dotdot_alarms_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/RelativityHumidity/SupportedCommands"; ++ topic += "/Alarms/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -104875,10 +103100,10 @@ void uic_mqtt_dotdot_relativity_humidity_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for OccupancySensing Cluster +-void uic_mqtt_dotdot_occupancy_sensing_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Time Cluster ++void uic_mqtt_dotdot_time_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/OccupancySensing/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Time/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -104895,13 +103120,13 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_cluster_revision(const char* base + true); + } + +-// Unretain Cluster Revision for OccupancySensing Cluster +-void uic_mqtt_dotdot_occupancy_sensing_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Time Cluster ++void uic_mqtt_dotdot_time_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/OccupancySensing/Attributes/ClusterRevision"; ++ + "/Time/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -104912,20 +103137,20 @@ void uic_mqtt_dotdot_occupancy_sensing_unretain_cluster_revision(const char* bas + } + + +-static inline bool uic_mqtt_dotdot_occupancy_sensing_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_time_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_occupancy_sensing_write_attributes_callback) { +- uic_mqtt_dotdot_occupancy_sensing_state_t occupancy_sensing_new_state = {}; +- uic_mqtt_dotdot_occupancy_sensing_updated_state_t occupancy_sensing_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_time_write_attributes_callback) { ++ uic_mqtt_dotdot_time_state_t time_new_state = {}; ++ uic_mqtt_dotdot_time_updated_state_t time_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- occupancy_sensing_new_state, +- occupancy_sensing_new_updated_state ++ time_new_state, ++ time_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -104933,17 +103158,17 @@ static inline bool uic_mqtt_dotdot_occupancy_sensing_write_attributes_is_support + return false; + } + +-static inline bool uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_time_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_callback) { +- uic_mqtt_dotdot_occupancy_sensing_updated_state_t occupancy_sensing_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_time_force_read_attributes_callback) { ++ uic_mqtt_dotdot_time_updated_state_t time_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- occupancy_sensing_force_update ++ time_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -104951,8 +103176,8 @@ static inline bool uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_is_su + return false; + } + +-// Publishing Supported Commands for OccupancySensing Cluster +-void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( ++// Publishing Supported Commands for Time Cluster ++void uic_mqtt_dotdot_time_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -104963,7 +103188,7 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( + // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_occupancy_sensing_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_time_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104972,7 +103197,7 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_time_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -104983,7 +103208,7 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/OccupancySensing/SupportedCommands"; ++ topic += "/Time/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -104995,7 +103220,7 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/OccupancySensing/Attributes"; ++ attributes_topic += "/Time/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105006,14 +103231,14 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for OccupancySensing Cluster +-void uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Time Cluster ++void uic_mqtt_dotdot_time_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/OccupancySensing/SupportedCommands"; ++ topic += "/Time/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105023,10 +103248,10 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for SoilMoisture Cluster +-void uic_mqtt_dotdot_soil_moisture_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for PollControl Cluster ++void uic_mqtt_dotdot_poll_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/SoilMoisture/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/PollControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -105043,13 +103268,13 @@ void uic_mqtt_dotdot_soil_moisture_publish_cluster_revision(const char* base_top + true); + } + +-// Unretain Cluster Revision for SoilMoisture Cluster +-void uic_mqtt_dotdot_soil_moisture_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for PollControl Cluster ++void uic_mqtt_dotdot_poll_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/SoilMoisture/Attributes/ClusterRevision"; ++ + "/PollControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -105059,169 +103284,107 @@ void uic_mqtt_dotdot_soil_moisture_unretain_cluster_revision(const char* base_to + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_soil_moisture_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_poll_control_check_in_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_soil_moisture_write_attributes_callback) { +- uic_mqtt_dotdot_soil_moisture_state_t soil_moisture_new_state = {}; +- uic_mqtt_dotdot_soil_moisture_updated_state_t soil_moisture_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- soil_moisture_new_state, +- soil_moisture_new_updated_state +- ) == SL_STATUS_OK) { ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_check_in_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_soil_moisture_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_poll_control_check_in_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_soil_moisture_force_read_attributes_callback) { +- uic_mqtt_dotdot_soil_moisture_updated_state_t soil_moisture_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- soil_moisture_force_update +- ) == SL_STATUS_OK) { ++ bool start_fast_polling_value; ++ memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); ++ int16_t fast_poll_timeout_value; ++ memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_check_in_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ start_fast_polling_value, ++ ++ fast_poll_timeout_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for SoilMoisture Cluster +-void uic_mqtt_dotdot_soil_moisture_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_poll_control_fast_poll_stop_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_soil_moisture_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_fast_poll_stop_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_soil_moisture_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_poll_control_set_long_poll_interval_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int32_t new_long_poll_interval_value; ++ memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ new_long_poll_interval_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/SoilMoisture/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/SoilMoisture/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for SoilMoisture Cluster +-void uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_poll_control_set_short_poll_interval_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/SoilMoisture/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ int16_t new_short_poll_interval_value; ++ memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ new_short_poll_interval_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} +- +-// Publishing Cluster Revision for PhMeasurement Cluster +-void uic_mqtt_dotdot_ph_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/PhMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for PhMeasurement Cluster +-void uic_mqtt_dotdot_ph_measurement_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/PhMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return false; + } + +- +-static inline bool uic_mqtt_dotdot_ph_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_poll_control_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ph_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_ph_measurement_state_t ph_measurement_new_state = {}; +- uic_mqtt_dotdot_ph_measurement_updated_state_t ph_measurement_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_write_attributes_callback) { ++ uic_mqtt_dotdot_poll_control_state_t poll_control_new_state = {}; ++ uic_mqtt_dotdot_poll_control_updated_state_t poll_control_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ph_measurement_new_state, +- ph_measurement_new_updated_state ++ poll_control_new_state, ++ poll_control_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -105229,17 +103392,17 @@ static inline bool uic_mqtt_dotdot_ph_measurement_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_ph_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_poll_control_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ph_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_ph_measurement_updated_state_t ph_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_poll_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_poll_control_updated_state_t poll_control_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ph_measurement_force_update ++ poll_control_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -105247,8 +103410,8 @@ static inline bool uic_mqtt_dotdot_ph_measurement_force_read_attributes_is_suppo + return false; + } + +-// Publishing Supported Commands for PhMeasurement Cluster +-void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( ++// Publishing Supported Commands for PollControl Cluster ++void uic_mqtt_dotdot_poll_control_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -105257,9 +103420,44 @@ void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command ++ if (uic_mqtt_dotdot_poll_control_check_in_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CheckIn")"; ++ } ++ if (uic_mqtt_dotdot_poll_control_check_in_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CheckInResponse")"; ++ } ++ if (uic_mqtt_dotdot_poll_control_fast_poll_stop_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("FastPollStop")"; ++ } ++ if (uic_mqtt_dotdot_poll_control_set_long_poll_interval_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetLongPollInterval")"; ++ } ++ if (uic_mqtt_dotdot_poll_control_set_short_poll_interval_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetShortPollInterval")"; ++ } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_ph_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_poll_control_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -105268,7 +103466,7 @@ void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_ph_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_poll_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -105279,7 +103477,7 @@ void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PhMeasurement/SupportedCommands"; ++ topic += "/PollControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -105291,7 +103489,7 @@ void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PhMeasurement/Attributes"; ++ attributes_topic += "/PollControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105302,14 +103500,14 @@ void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for PhMeasurement Cluster +-void uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for PollControl Cluster ++void uic_mqtt_dotdot_poll_control_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PhMeasurement/SupportedCommands"; ++ topic += "/PollControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105319,10 +103517,10 @@ void uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for ElectricalConductivityMeasurement Cluster +-void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for ShadeConfiguration Cluster ++void uic_mqtt_dotdot_shade_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/ElectricalConductivityMeasurement/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/ShadeConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -105339,13 +103537,13 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_cluster_revisio + true); + } + +-// Unretain Cluster Revision for ElectricalConductivityMeasurement Cluster +-void uic_mqtt_dotdot_electrical_conductivity_measurement_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for ShadeConfiguration Cluster ++void uic_mqtt_dotdot_shade_configuration_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/ElectricalConductivityMeasurement/Attributes/ClusterRevision"; ++ + "/ShadeConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -105356,20 +103554,20 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_unretain_cluster_revisi + } + + +-static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_shade_configuration_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_electrical_conductivity_measurement_state_t electrical_conductivity_measurement_new_state = {}; +- uic_mqtt_dotdot_electrical_conductivity_measurement_updated_state_t electrical_conductivity_measurement_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_shade_configuration_write_attributes_callback) { ++ uic_mqtt_dotdot_shade_configuration_state_t shade_configuration_new_state = {}; ++ uic_mqtt_dotdot_shade_configuration_updated_state_t shade_configuration_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- electrical_conductivity_measurement_new_state, +- electrical_conductivity_measurement_new_updated_state ++ shade_configuration_new_state, ++ shade_configuration_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -105377,17 +103575,17 @@ static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_write_att + return false; + } + +-static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_shade_configuration_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_electrical_conductivity_measurement_updated_state_t electrical_conductivity_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_shade_configuration_force_read_attributes_callback) { ++ uic_mqtt_dotdot_shade_configuration_updated_state_t shade_configuration_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- electrical_conductivity_measurement_force_update ++ shade_configuration_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -105395,8 +103593,8 @@ static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_force_rea + return false; + } + +-// Publishing Supported Commands for ElectricalConductivityMeasurement Cluster +-void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_commands( ++// Publishing Supported Commands for ShadeConfiguration Cluster ++void uic_mqtt_dotdot_shade_configuration_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -105407,7 +103605,7 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_comma + // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_shade_configuration_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -105416,7 +103614,7 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_comma + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_shade_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -105427,7 +103625,7 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_comma + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ElectricalConductivityMeasurement/SupportedCommands"; ++ topic += "/ShadeConfiguration/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -105439,7 +103637,7 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_comma + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ElectricalConductivityMeasurement/Attributes"; ++ attributes_topic += "/ShadeConfiguration/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105450,14 +103648,14 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_comma + } + } + +-// Publishing empty/no Supported Commands for ElectricalConductivityMeasurement Cluster +-void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for ShadeConfiguration Cluster ++void uic_mqtt_dotdot_shade_configuration_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ElectricalConductivityMeasurement/SupportedCommands"; ++ topic += "/ShadeConfiguration/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -105467,10 +103665,10 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported + } + } + +-// Publishing Cluster Revision for WindSpeedMeasurement Cluster +-void uic_mqtt_dotdot_wind_speed_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for DoorLock Cluster ++void uic_mqtt_dotdot_door_lock_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/WindSpeedMeasurement/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/DoorLock/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -105487,13 +103685,13 @@ void uic_mqtt_dotdot_wind_speed_measurement_publish_cluster_revision(const char* + true); + } + +-// Unretain Cluster Revision for WindSpeedMeasurement Cluster +-void uic_mqtt_dotdot_wind_speed_measurement_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for DoorLock Cluster ++void uic_mqtt_dotdot_door_lock_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/WindSpeedMeasurement/Attributes/ClusterRevision"; ++ + "/DoorLock/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -105503,612 +103701,618 @@ void uic_mqtt_dotdot_wind_speed_measurement_unretain_cluster_revision(const char + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_wind_speed_measurement_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_lock_door_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_wind_speed_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_wind_speed_measurement_state_t wind_speed_measurement_new_state = {}; +- uic_mqtt_dotdot_wind_speed_measurement_updated_state_t wind_speed_measurement_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- wind_speed_measurement_new_state, +- wind_speed_measurement_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t pin_or_rfid_code_value; ++ memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_lock_door_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_or_rfid_code_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_lock_door_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_wind_speed_measurement_updated_state_t wind_speed_measurement_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- wind_speed_measurement_force_update +- ) == SL_STATUS_OK) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_lock_door_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for WindSpeedMeasurement Cluster +-void uic_mqtt_dotdot_wind_speed_measurement_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_unlock_door_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_wind_speed_measurement_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ uint8_t pin_or_rfid_code_value; ++ memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_door_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_or_rfid_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_unlock_door_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_door_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/WindSpeedMeasurement/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/WindSpeedMeasurement/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_toggle_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t pin_or_rfid_code_value; ++ memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_toggle_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_or_rfid_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} + +-// Publishing empty/no Supported Commands for WindSpeedMeasurement Cluster +-void uic_mqtt_dotdot_wind_speed_measurement_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_toggle_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/WindSpeedMeasurement/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_toggle_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for CarbonMonoxide Cluster +-void uic_mqtt_dotdot_carbon_monoxide_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/CarbonMonoxide/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for CarbonMonoxide Cluster +-void uic_mqtt_dotdot_carbon_monoxide_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_door_lock_unlock_with_timeout_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/CarbonMonoxide/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- ++ int16_t timeout_in_seconds_value; ++ memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); ++ uint8_t pin_or_rfid_code_value; ++ memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ timeout_in_seconds_value, ++ ++ pin_or_rfid_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_carbon_monoxide_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_carbon_monoxide_write_attributes_callback) { +- uic_mqtt_dotdot_carbon_monoxide_state_t carbon_monoxide_new_state = {}; +- uic_mqtt_dotdot_carbon_monoxide_updated_state_t carbon_monoxide_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- carbon_monoxide_new_state, +- carbon_monoxide_new_updated_state +- ) == SL_STATUS_OK) { ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_log_record_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_callback) { +- uic_mqtt_dotdot_carbon_monoxide_updated_state_t carbon_monoxide_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- carbon_monoxide_force_update +- ) == SL_STATUS_OK) { ++ int16_t log_index_value; ++ memset(&log_index_value, 0x00, sizeof(log_index_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ log_index_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for CarbonMonoxide Cluster +-void uic_mqtt_dotdot_carbon_monoxide_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_get_log_record_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_carbon_monoxide_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ int16_t log_entryid_value; ++ memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); ++ int32_t timestamp_value; ++ memset(×tamp_value, 0x00, sizeof(timestamp_value)); ++ GetLogRecordResponseEventType event_type_value; ++ memset(&event_type_value, 0x00, sizeof(event_type_value)); ++ DrlkOperEventSource source_operation_event_value; ++ memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); ++ int8_t event_id_or_alarm_code_value; ++ memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ uint8_t pin_value; ++ memset(&pin_value, 0x00, sizeof(pin_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ log_entryid_value, ++ ++ timestamp_value, ++ ++ event_type_value, ++ ++ source_operation_event_value, ++ ++ event_id_or_alarm_code_value, ++ ++ userid_value, ++ ++ pin_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_pin_code_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkSettableUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ uint8_t pin_value; ++ memset(&pin_value, 0x00, sizeof(pin_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_pin_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value, ++ ++ user_type_value, ++ ++ pin_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/CarbonMonoxide/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/CarbonMonoxide/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_pin_code_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ DrlkSetCodeStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_pin_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} + +-// Publishing empty/no Supported Commands for CarbonMonoxide Cluster +-void uic_mqtt_dotdot_carbon_monoxide_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/CarbonMonoxide/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for CarbonDioxide Cluster +-void uic_mqtt_dotdot_carbon_dioxide_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/CarbonDioxide/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for CarbonDioxide Cluster +-void uic_mqtt_dotdot_carbon_dioxide_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/CarbonDioxide/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ uint8_t code_value; ++ memset(&code_value, 0x00, sizeof(code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value, ++ ++ user_type_value, ++ ++ code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_carbon_dioxide_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_pin_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_carbon_dioxide_write_attributes_callback) { +- uic_mqtt_dotdot_carbon_dioxide_state_t carbon_dioxide_new_state = {}; +- uic_mqtt_dotdot_carbon_dioxide_updated_state_t carbon_dioxide_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- carbon_dioxide_new_state, +- carbon_dioxide_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_clear_pin_code_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_callback) { +- uic_mqtt_dotdot_carbon_dioxide_updated_state_t carbon_dioxide_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- carbon_dioxide_force_update +- ) == SL_STATUS_OK) { ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_pin_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for CarbonDioxide Cluster +-void uic_mqtt_dotdot_carbon_dioxide_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_clear_all_pin_codes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_carbon_dioxide_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_pin_codes_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/CarbonDioxide/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/CarbonDioxide/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for CarbonDioxide Cluster +-void uic_mqtt_dotdot_carbon_dioxide_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_door_lock_set_user_status_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/CarbonDioxide/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkSettableUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_status_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for PM25 Cluster +-void uic_mqtt_dotdot_pm25_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/PM25/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for PM25 Cluster +-void uic_mqtt_dotdot_pm25_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_door_lock_set_user_status_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/PM25/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_status_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_pm25_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_user_status_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pm25_write_attributes_callback) { +- uic_mqtt_dotdot_pm25_state_t pm25_new_state = {}; +- uic_mqtt_dotdot_pm25_updated_state_t pm25_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pm25_new_state, +- pm25_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_status_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_pm25_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_user_status_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_pm25_force_read_attributes_callback) { +- uic_mqtt_dotdot_pm25_updated_state_t pm25_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- pm25_force_update +- ) == SL_STATUS_OK) { ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for PM25 Cluster +-void uic_mqtt_dotdot_pm25_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_set_weekday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_pm25_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ uint8_t days_mask_value; ++ memset(&days_mask_value, 0x00, sizeof(days_mask_value)); ++ int8_t start_hour_value; ++ memset(&start_hour_value, 0x00, sizeof(start_hour_value)); ++ int8_t start_minute_value; ++ memset(&start_minute_value, 0x00, sizeof(start_minute_value)); ++ int8_t end_hour_value; ++ memset(&end_hour_value, 0x00, sizeof(end_hour_value)); ++ int8_t end_minute_value; ++ memset(&end_minute_value, 0x00, sizeof(end_minute_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ scheduleid_value, ++ ++ userid_value, ++ ++ days_mask_value, ++ ++ start_hour_value, ++ ++ start_minute_value, ++ ++ end_hour_value, ++ ++ end_minute_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_pm25_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PM25/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/PM25/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ scheduleid_value, ++ ++ userid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} + +-// Publishing empty/no Supported Commands for PM25 Cluster +-void uic_mqtt_dotdot_pm25_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/PM25/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ int8_t scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ uint8_t days_mask_value; ++ memset(&days_mask_value, 0x00, sizeof(days_mask_value)); ++ int8_t start_hour_value; ++ memset(&start_hour_value, 0x00, sizeof(start_hour_value)); ++ int8_t start_minute_value; ++ memset(&start_minute_value, 0x00, sizeof(start_minute_value)); ++ int8_t end_hour_value; ++ memset(&end_hour_value, 0x00, sizeof(end_hour_value)); ++ int8_t end_minute_value; ++ memset(&end_minute_value, 0x00, sizeof(end_minute_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ scheduleid_value, ++ ++ userid_value, ++ ++ status_value, ++ ++ days_mask_value, ++ ++ start_hour_value, ++ ++ start_minute_value, ++ ++ end_hour_value, ++ ++ end_minute_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for IASZone Cluster +-void uic_mqtt_dotdot_ias_zone_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/IASZone/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for IASZone Cluster +-void uic_mqtt_dotdot_ias_zone_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_door_lock_clear_weekday_schedule_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/IASZone/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ scheduleid_value, ++ ++ userid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; +- memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- uint8_t zoneid_value; +- memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback) { ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- enroll_response_code_value, +- +- zoneid_value ++ status_value + + ) == SL_STATUS_OK) { + return true; +@@ -106117,28 +104321,28 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_set_year_day_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint16_t zone_status_value; +- memset(&zone_status_value, 0x00, sizeof(zone_status_value)); +- uint8_t extended_status_value; +- memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- uint8_t zoneid_value; +- memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- uint16_t delay_value; +- memset(&delay_value, 0x00, sizeof(delay_value)); +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback) { ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ int32_t local_start_time_value; ++ memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); ++ int32_t local_end_time_value; ++ memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- zone_status_value, ++ scheduleid_value, + +- extended_status_value, ++ userid_value, + +- zoneid_value, ++ local_start_time_value, + +- delay_value ++ local_end_time_value + + ) == SL_STATUS_OK) { + return true; +@@ -106147,12 +104351,16 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_s + + return false; + } +-static inline bool uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_callback) { ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value + + ) == SL_STATUS_OK) { + return true; +@@ -106161,20 +104369,20 @@ static inline bool uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_is_su + + return false; + } +-static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- IasZoneType zone_type_value; +- memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- uint16_t manufacturer_code_value; +- memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback) { ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- zone_type_value, ++ scheduleid_value, + +- manufacturer_code_value ++ userid_value + + ) == SL_STATUS_OK) { + return true; +@@ -106183,20 +104391,32 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t test_mode_duration_value; +- memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- uint8_t current_zone_sensitivity_level_value; +- memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { ++ int8_t scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int32_t local_start_time_value; ++ memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); ++ int32_t local_end_time_value; ++ memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- test_mode_duration_value, ++ scheduleid_value, + +- current_zone_sensitivity_level_value ++ userid_value, ++ ++ status_value, ++ ++ local_start_time_value, ++ ++ local_end_time_value + + ) == SL_STATUS_OK) { + return true; +@@ -106205,211 +104425,138 @@ static inline bool uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported( + + return false; + } +- +-static inline bool uic_mqtt_dotdot_ias_zone_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_clear_year_day_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_write_attributes_callback) { +- uic_mqtt_dotdot_ias_zone_state_t ias_zone_new_state = {}; +- uic_mqtt_dotdot_ias_zone_updated_state_t ias_zone_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ias_zone_new_state, +- ias_zone_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t * scheduleid_value; ++ memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ scheduleid_value, ++ ++ userid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_ias_zone_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_ias_zone_force_read_attributes_callback) { +- uic_mqtt_dotdot_ias_zone_updated_state_t ias_zone_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- ias_zone_force_update +- ) == SL_STATUS_OK) { ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for IASZone Cluster +-void uic_mqtt_dotdot_ias_zone_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_set_holiday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ZoneEnrollResponse")"; +- } +- if (uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ZoneStatusChangeNotification")"; +- } +- if (uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("InitiateNormalOperationMode")"; +- } +- if (uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ZoneEnrollRequest")"; +- } +- if (uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("InitiateTestMode")"; +- } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_ias_zone_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ uint8_t * holiday_scheduleid_value; ++ memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); ++ int32_t local_start_time_value; ++ memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); ++ int32_t local_end_time_value; ++ memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); ++ DrlkOperMode operating_mode_during_holiday_value; ++ memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ holiday_scheduleid_value, ++ ++ local_start_time_value, ++ ++ local_end_time_value, ++ ++ operating_mode_during_holiday_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_ias_zone_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IASZone/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/IASZone/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for IASZone Cluster +-void uic_mqtt_dotdot_ias_zone_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IASZone/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uint8_t * holiday_scheduleid_value; ++ memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ holiday_scheduleid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} +- +-// Publishing Cluster Revision for IASWD Cluster +-void uic_mqtt_dotdot_iaswd_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/IASWD/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} + +-// Unretain Cluster Revision for IASWD Cluster +-void uic_mqtt_dotdot_iaswd_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/IASWD/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ return false; + } +- +-static inline bool uic_mqtt_dotdot_iaswd_start_warning_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t siren_configuration_value; +- memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- uint16_t warning_duration_value; +- memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- uint8_t strobe_duty_cycle_value; +- memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); +- IaswdLevel strobe_level_value; +- memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +- for (const auto& callback: uic_mqtt_dotdot_iaswd_start_warning_callback) { ++ int8_t holiday_scheduleid_value; ++ memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); ++ zclStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ int32_t local_start_time_value; ++ memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); ++ int32_t local_end_time_value; ++ memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); ++ DrlkOperMode operating_mode_during_holiday_value; ++ memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- siren_configuration_value, ++ holiday_scheduleid_value, + +- warning_duration_value, ++ status_value, + +- strobe_duty_cycle_value, ++ local_start_time_value, + +- strobe_level_value ++ local_end_time_value, ++ ++ operating_mode_during_holiday_value + + ) == SL_STATUS_OK) { + return true; +@@ -106418,16 +104565,16 @@ static inline bool uic_mqtt_dotdot_iaswd_start_warning_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_iaswd_squawk_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_clear_holiday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t squawk_configuration_value; +- memset(&squawk_configuration_value, 0x00, sizeof(squawk_configuration_value)); +- for (const auto& callback: uic_mqtt_dotdot_iaswd_squawk_callback) { ++ uint8_t * holiday_scheduleid_value; ++ memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- squawk_configuration_value ++ holiday_scheduleid_value + + ) == SL_STATUS_OK) { + return true; +@@ -106436,337 +104583,391 @@ static inline bool uic_mqtt_dotdot_iaswd_squawk_is_supported( + + return false; + } +- +-static inline bool uic_mqtt_dotdot_iaswd_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_iaswd_write_attributes_callback) { +- uic_mqtt_dotdot_iaswd_state_t iaswd_new_state = {}; +- uic_mqtt_dotdot_iaswd_updated_state_t iaswd_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- iaswd_new_state, +- iaswd_new_updated_state +- ) == SL_STATUS_OK) { ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_iaswd_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_set_user_type_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_iaswd_force_read_attributes_callback) { +- uic_mqtt_dotdot_iaswd_updated_state_t iaswd_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- iaswd_force_update +- ) == SL_STATUS_OK) { ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_type_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_type_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for IASWD Cluster +-void uic_mqtt_dotdot_iaswd_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_set_user_type_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_iaswd_start_warning_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("StartWarning")"; +- } +- if (uic_mqtt_dotdot_iaswd_squawk_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_type_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("Squawk")"; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_iaswd_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_user_type_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_type_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_iaswd_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_user_type_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_type_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IASWD/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/IASWD/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for IASWD Cluster +-void uic_mqtt_dotdot_iaswd_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_door_lock_set_rfid_code_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/IASWD/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkSettableUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ uint8_t rfid_code_value; ++ memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value, ++ ++ user_type_value, ++ ++ rfid_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for Metering Cluster +-void uic_mqtt_dotdot_metering_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/Metering/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for Metering Cluster +-void uic_mqtt_dotdot_metering_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_door_lock_set_rfid_code_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Metering/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- ++ DrlkSetCodeStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_rfid_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_metering_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_metering_write_attributes_callback) { +- uic_mqtt_dotdot_metering_state_t metering_new_state = {}; +- uic_mqtt_dotdot_metering_updated_state_t metering_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- metering_new_state, +- metering_new_updated_state +- ) == SL_STATUS_OK) { ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_metering_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_metering_force_read_attributes_callback) { +- uic_mqtt_dotdot_metering_updated_state_t metering_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- metering_force_update +- ) == SL_STATUS_OK) { ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ DrlkUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ uint8_t rfid_code_value; ++ memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value, ++ ++ user_status_value, ++ ++ user_type_value, ++ ++ rfid_code_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for Metering Cluster +-void uic_mqtt_dotdot_metering_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_door_lock_clear_rfid_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_metering_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ uint8_t * userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ userid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_metering_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_rfid_code_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_rfid_code_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Metering/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Metering/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; + } + } +-} + +-// Publishing empty/no Supported Commands for Metering Cluster +-void uic_mqtt_dotdot_metering_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Metering/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ DrlkPassFailStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ status_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for ElectricalMeasurement Cluster +-void uic_mqtt_dotdot_electrical_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string cluster_topic = std::string(base_topic) + "/ElectricalMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ DataOperationTypeEnum operation_type_value; ++ memset(&operation_type_value, 0x00, sizeof(operation_type_value)); ++ int16_t user_index_value; ++ memset(&user_index_value, 0x00, sizeof(user_index_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int32_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ DrlkSettableUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ CredentialRuleEnum credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ operation_type_value, ++ ++ user_index_value, ++ ++ user_name_value, ++ ++ user_uniqueid_value, ++ ++ user_status_value, ++ ++ user_type_value, ++ ++ credential_rule_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; + } ++static inline bool uic_mqtt_dotdot_door_lock_get_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_index_value; ++ memset(&user_index_value, 0x00, sizeof(user_index_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_index_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-// Unretain Cluster Revision for ElectricalMeasurement Cluster +-void uic_mqtt_dotdot_electrical_measurement_unretain_cluster_revision(const char* base_topic) ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_user_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/ElectricalMeasurement/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; + } ++static inline bool uic_mqtt_dotdot_door_lock_clear_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_index_value; ++ memset(&user_index_value, 0x00, sizeof(user_index_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_index_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_operating_event_notification_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t profile_count_value; +- memset(&profile_count_value, 0x00, sizeof(profile_count_value)); +- ProfileIntervalPeriod profile_interval_period_value; +- memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t max_number_of_intervals_value; +- memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { ++ DrlkOperEventSource operation_event_source_value; ++ memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); ++ OperatingEventNotificationOperationEventCode operation_event_code_value; ++ memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ uint8_t pin_value; ++ memset(&pin_value, 0x00, sizeof(pin_value)); ++ int32_t local_time_value; ++ memset(&local_time_value, 0x00, sizeof(local_time_value)); ++ const char* data_value; ++ memset(&data_value, 0x00, sizeof(data_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_operating_event_notification_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- profile_count_value, ++ operation_event_source_value, + +- profile_interval_period_value, ++ operation_event_code_value, + +- max_number_of_intervals_value, ++ userid_value, ++ ++ pin_value, ++ ++ local_time_value, ++ ++ data_value + +- 0, nullptr +- + ) == SL_STATUS_OK) { + return true; + } +@@ -106774,12 +104975,44 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_respo + + return false; + } +-static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_programming_event_notification_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_profile_info_callback) { ++ ProgrammingEventNotificationProgramEventSource program_event_source_value; ++ memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); ++ ProgrammingEventNotificationProgramEventCode program_event_code_value; ++ memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); ++ int16_t userid_value; ++ memset(&userid_value, 0x00, sizeof(userid_value)); ++ uint8_t pin_value; ++ memset(&pin_value, 0x00, sizeof(pin_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ DrlkUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ int32_t local_time_value; ++ memset(&local_time_value, 0x00, sizeof(local_time_value)); ++ const char* data_value; ++ memset(&data_value, 0x00, sizeof(data_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_programming_event_notification_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ program_event_source_value, ++ ++ program_event_code_value, ++ ++ userid_value, ++ ++ pin_value, ++ ++ user_type_value, ++ ++ user_status_value, ++ ++ local_time_value, ++ ++ data_value + + ) == SL_STATUS_OK) { + return true; +@@ -106788,35 +105021,51 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_is_su + + return false; + } +-static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_set_credential_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint32_t start_time_value; +- memset(&start_time_value, 0x00, sizeof(start_time_value)); +- GetMeasurementProfileResponseStatus status_value; +- memset(&status_value, 0x00, sizeof(status_value)); +- ProfileIntervalPeriod profile_interval_period_value; +- memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t number_of_intervals_delivered_value; +- memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint16_t attribute_id_value; +- memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { ++ DataOperationTypeEnum operation_type_value; ++ memset(&operation_type_value, 0x00, sizeof(operation_type_value)); ++ CredentialStruct credential_value; ++ memset(&credential_value, 0x00, sizeof(credential_value)); ++ uint8_t credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ int16_t user_index_value; ++ memset(&user_index_value, 0x00, sizeof(user_index_value)); ++ DrlkSettableUserStatus user_status_value; ++ memset(&user_status_value, 0x00, sizeof(user_status_value)); ++ DrlkUserType user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_credential_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- start_time_value, ++ operation_type_value, + +- status_value, ++ credential_value, + +- profile_interval_period_value, ++ credential_data_value, + +- number_of_intervals_delivered_value, ++ user_index_value, + +- attribute_id_value, ++ user_status_value, + +- 0, nullptr ++ user_type_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_set_credential_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_set_credential_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ + ) == SL_STATUS_OK) { + return true; + } +@@ -106824,24 +105073,48 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + + return false; + } +-static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_get_credential_status_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint16_t attributeid_value; +- memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint32_t start_time_value; +- memset(&start_time_value, 0x00, sizeof(start_time_value)); +- uint8_t number_of_intervals_value; +- memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { ++ CredentialStruct credential_value; ++ memset(&credential_value, 0x00, sizeof(credential_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_credential_status_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- attributeid_value, ++ credential_value + +- start_time_value, ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_get_credential_status_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_get_credential_status_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + +- number_of_intervals_value ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_door_lock_clear_credential_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CredentialStruct credential_value; ++ memset(&credential_value, 0x00, sizeof(credential_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_credential_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_value + + ) == SL_STATUS_OK) { + return true; +@@ -106850,21 +105123,39 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + + return false; + } ++static inline bool uic_mqtt_dotdot_door_lock_unbolt_door_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t pin_code_value; ++ memset(&pin_code_value, 0x00, sizeof(pin_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_unbolt_door_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_electrical_measurement_write_attributes_is_supported( ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_door_lock_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_write_attributes_callback) { +- uic_mqtt_dotdot_electrical_measurement_state_t electrical_measurement_new_state = {}; +- uic_mqtt_dotdot_electrical_measurement_updated_state_t electrical_measurement_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_write_attributes_callback) { ++ uic_mqtt_dotdot_door_lock_state_t door_lock_new_state = {}; ++ uic_mqtt_dotdot_door_lock_updated_state_t door_lock_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- electrical_measurement_new_state, +- electrical_measurement_new_updated_state ++ door_lock_new_state, ++ door_lock_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -106872,17 +105163,17 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_write_attributes_is_su + return false; + } + +-static inline bool uic_mqtt_dotdot_electrical_measurement_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_door_lock_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_force_read_attributes_callback) { +- uic_mqtt_dotdot_electrical_measurement_updated_state_t electrical_measurement_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_door_lock_force_read_attributes_callback) { ++ uic_mqtt_dotdot_door_lock_updated_state_t door_lock_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- electrical_measurement_force_update ++ door_lock_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -106890,8 +105181,8 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_force_read_attributes_ + return false; + } + +-// Publishing Supported Commands for ElectricalMeasurement Cluster +-void uic_mqtt_dotdot_electrical_measurement_publish_supported_commands( ++// Publishing Supported Commands for DoorLock Cluster ++void uic_mqtt_dotdot_door_lock_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -106900,185 +105191,457 @@ void uic_mqtt_dotdot_electrical_measurement_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_lock_door_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetProfileInfoResponse")"; ++ ss << R"("LockDoor")"; + } +- if (uic_mqtt_dotdot_electrical_measurement_get_profile_info_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_lock_door_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetProfileInfo")"; ++ ss << R"("LockDoorResponse")"; + } +- if (uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_unlock_door_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetMeasurementProfileResponse")"; ++ ss << R"("UnlockDoor")"; + } +- if (uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_unlock_door_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("GetMeasurementProfile")"; ++ ss << R"("UnlockDoorResponse")"; + } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_electrical_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_toggle_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("WriteAttributes")"; ++ ss << R"("Toggle")"; + } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_electrical_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_toggle_response_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("ForceReadAttributes")"; ++ ss << R"("ToggleResponse")"; + } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ElectricalMeasurement/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ElectricalMeasurement/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_door_lock_unlock_with_timeout_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("UnlockWithTimeout")"; + } +-} +- +-// Publishing empty/no Supported Commands for ElectricalMeasurement Cluster +-void uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ElectricalMeasurement/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ if (uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("UnlockWithTimeoutResponse")"; + } +-} +- +-// Publishing Cluster Revision for Diagnostics Cluster +-void uic_mqtt_dotdot_diagnostics_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/Diagnostics/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} +- +-// Unretain Cluster Revision for Diagnostics Cluster +-void uic_mqtt_dotdot_diagnostics_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/Diagnostics/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- +- +-static inline bool uic_mqtt_dotdot_diagnostics_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_diagnostics_write_attributes_callback) { +- uic_mqtt_dotdot_diagnostics_state_t diagnostics_new_state = {}; +- uic_mqtt_dotdot_diagnostics_updated_state_t diagnostics_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- diagnostics_new_state, +- diagnostics_new_updated_state +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_door_lock_get_log_record_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("GetLogRecord")"; + } +- return false; +-} +- +-static inline bool uic_mqtt_dotdot_diagnostics_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_diagnostics_force_read_attributes_callback) { +- uic_mqtt_dotdot_diagnostics_updated_state_t diagnostics_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- diagnostics_force_update +- ) == SL_STATUS_OK) { +- return true; ++ if (uic_mqtt_dotdot_door_lock_get_log_record_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; + } ++ first_command = false; ++ ss << R"("GetLogRecordResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_pin_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetPINCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_pin_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetPINCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_pin_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetPINCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_pin_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetPINCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_pin_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearPINCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_pin_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearPINCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_all_pin_codes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearAllPINCodes")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_all_pin_codes_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearAllPINCodesResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_user_status_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetUserStatus")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_user_status_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetUserStatusResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_status_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserStatus")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_status_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserStatusResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_weekday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetWeekdaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetWeekdayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_weekday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetWeekdaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetWeekdayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_weekday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearWeekdaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearWeekdayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_year_day_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetYearDaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetYearDayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_year_day_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetYearDaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetYearDayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_year_day_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearYearDaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearYearDayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_holiday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetHolidaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_holiday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetHolidayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_holiday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetHolidaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetHolidayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_holiday_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearHolidaySchedule")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearHolidayScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_user_type_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetUserType")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_user_type_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetUserTypeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_type_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserType")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_type_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserTypeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_rfid_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetRFIDCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_rfid_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetRFIDCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_rfid_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetRFIDCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_rfid_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetRFIDCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_rfid_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearRFIDCode")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_rfid_code_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearRFIDCodeResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearAllRFIDCodes")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_all_rfid_codes_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearAllRFIDCodesResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetUser")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUser")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_user_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearUser")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_operating_event_notification_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("OperatingEventNotification")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_programming_event_notification_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ProgrammingEventNotification")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_credential_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetCredential")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_set_credential_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetCredentialResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_credential_status_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetCredentialStatus")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_get_credential_status_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetCredentialStatusResponse")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_clear_credential_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearCredential")"; ++ } ++ if (uic_mqtt_dotdot_door_lock_unbolt_door_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("UnboltDoor")"; + } +- return false; +-} +- +-// Publishing Supported Commands for Diagnostics Cluster +-void uic_mqtt_dotdot_diagnostics_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_diagnostics_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_door_lock_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107087,7 +105650,7 @@ void uic_mqtt_dotdot_diagnostics_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_diagnostics_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_door_lock_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107098,7 +105661,7 @@ void uic_mqtt_dotdot_diagnostics_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Diagnostics/SupportedCommands"; ++ topic += "/DoorLock/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -107110,7 +105673,7 @@ void uic_mqtt_dotdot_diagnostics_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Diagnostics/Attributes"; ++ attributes_topic += "/DoorLock/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107121,14 +105684,14 @@ void uic_mqtt_dotdot_diagnostics_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for Diagnostics Cluster +-void uic_mqtt_dotdot_diagnostics_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for DoorLock Cluster ++void uic_mqtt_dotdot_door_lock_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Diagnostics/SupportedCommands"; ++ topic += "/DoorLock/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107138,10 +105701,10 @@ void uic_mqtt_dotdot_diagnostics_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for ProtocolController-RFTelemetry Cluster +-void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for WindowCovering Cluster ++void uic_mqtt_dotdot_window_covering_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/ProtocolController/RFTelemetry/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/WindowCovering/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -107158,13 +105721,13 @@ void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_cluster_revision(c + true); + } + +-// Unretain Cluster Revision for ProtocolController-RFTelemetry Cluster +-void uic_mqtt_dotdot_protocol_controller_rf_telemetry_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for WindowCovering Cluster ++void uic_mqtt_dotdot_window_covering_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/ProtocolController/RFTelemetry/Attributes/ClusterRevision"; ++ + "/WindowCovering/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -107174,252 +105737,26 @@ void uic_mqtt_dotdot_protocol_controller_rf_telemetry_unretain_cluster_revision( + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_up_or_open_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- const char* sourceunid_value; +- memset(&sourceunid_value, 0x00, sizeof(sourceunid_value)); +- const char* destinationunid_value; +- memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); +- bool transmission_successful_value; +- memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- uint16_t transmission_time_ms_value; +- memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); +- int8_t tx_powerd_bm_value; +- memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- uint8_t tx_channel_value; +- memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- uint8_t routing_attempts_value; +- memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); +- bool route_changed_value; +- memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +- TxReportTransmissionSpeed transmission_speed_value; +- memset(&transmission_speed_value, 0x00, sizeof(transmission_speed_value)); +- int8_t measured_noise_floord_bm_value; +- memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); +- int8_t ackrssi_value; +- memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- uint8_t ack_channel_value; +- memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); +- const char* last_route_failed_link_functionalunid_value; +- memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +- const char* last_route_failed_link_non_functionalunid_value; +- memset(&last_route_failed_link_non_functionalunid_value, 0x00, sizeof(last_route_failed_link_non_functionalunid_value)); +- int8_t destination_ack_tx_powerd_bm_value; +- memset(&destination_ack_tx_powerd_bm_value, 0x00, sizeof(destination_ack_tx_powerd_bm_value)); +- int8_t destination_ack_measuredrssi_value; +- memset(&destination_ack_measuredrssi_value, 0x00, sizeof(destination_ack_measuredrssi_value)); +- int8_t destination_ack_measured_noise_floor_value; +- memset(&destination_ack_measured_noise_floor_value, 0x00, sizeof(destination_ack_measured_noise_floor_value)); +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_callback) { ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_up_or_open_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- sourceunid_value, +- +- destinationunid_value, +- +- transmission_successful_value, + +- transmission_time_ms_value, +- +- tx_powerd_bm_value, +- +- tx_channel_value, +- +- routing_attempts_value, +- +- route_changed_value, +- +- transmission_speed_value, +- +- measured_noise_floord_bm_value, +- +- 0, nullptr, +- +- 0, nullptr, +- +- ackrssi_value, +- +- ack_channel_value, +- +- last_route_failed_link_functionalunid_value, +- +- last_route_failed_link_non_functionalunid_value, +- +- destination_ack_tx_powerd_bm_value, +- +- destination_ack_measuredrssi_value, +- +- destination_ack_measured_noise_floor_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +- +-static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_callback) { +- uic_mqtt_dotdot_protocol_controller_rf_telemetry_state_t protocol_controller_rf_telemetry_new_state = {}; +- uic_mqtt_dotdot_protocol_controller_rf_telemetry_updated_state_t protocol_controller_rf_telemetry_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- protocol_controller_rf_telemetry_new_state, +- protocol_controller_rf_telemetry_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} +- +-static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_callback) { +- uic_mqtt_dotdot_protocol_controller_rf_telemetry_updated_state_t protocol_controller_rf_telemetry_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- protocol_controller_rf_telemetry_force_update +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} +- +-// Publishing Supported Commands for ProtocolController-RFTelemetry Cluster +-void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_supported_commands( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("TxReport")"; +- } +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } +- +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } +- +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- +- topic += "/ProtocolController/RFTelemetry/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- +- attributes_topic += "/ProtocolController/RFTelemetry/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } +-} +- +-// Publishing empty/no Supported Commands for ProtocolController-RFTelemetry Cluster +-void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_empty_supported_commands( +- const dotdot_unid_t unid +- ) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ProtocolController/RFTelemetry/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +-} +- +-// Publishing Cluster Revision for State Cluster +-void uic_mqtt_dotdot_state_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/State/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); +-} +- +-// Unretain Cluster Revision for State Cluster +-void uic_mqtt_dotdot_state_unretain_cluster_revision(const char* base_topic) +-{ +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/State/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} +- +-static inline bool uic_mqtt_dotdot_state_remove_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_state_remove_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_window_covering_down_or_close_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_down_or_close_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + + ) == SL_STATUS_OK) { + return true; +@@ -107428,11 +105765,11 @@ static inline bool uic_mqtt_dotdot_state_remove_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_state_remove_offline_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_stop_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_remove_offline_callback) { ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_stop_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + + ) == SL_STATUS_OK) { +@@ -107442,12 +105779,16 @@ static inline bool uic_mqtt_dotdot_state_remove_offline_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_state_discover_neighbors_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_value_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_discover_neighbors_callback) { ++ int16_t lift_value_value; ++ memset(&lift_value_value, 0x00, sizeof(lift_value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ lift_value_value + + ) == SL_STATUS_OK) { + return true; +@@ -107456,12 +105797,16 @@ static inline bool uic_mqtt_dotdot_state_discover_neighbors_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_state_interview_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_percentage_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_interview_callback) { ++ int8_t percentage_lift_value_value; ++ memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ percentage_lift_value_value + + ) == SL_STATUS_OK) { + return true; +@@ -107470,12 +105815,16 @@ static inline bool uic_mqtt_dotdot_state_interview_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_state_discover_security_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_value_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_discover_security_callback) { ++ int16_t tilt_value_value; ++ memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ tilt_value_value + + ) == SL_STATUS_OK) { + return true; +@@ -107484,12 +105833,16 @@ static inline bool uic_mqtt_dotdot_state_discover_security_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_state_enable_nls_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_enable_nls_callback) { ++ int8_t percentage_tilt_value_value; ++ memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ percentage_tilt_value_value + + ) == SL_STATUS_OK) { + return true; +@@ -107499,20 +105852,20 @@ static inline bool uic_mqtt_dotdot_state_enable_nls_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_state_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_write_attributes_callback) { +- uic_mqtt_dotdot_state_state_t state_new_state = {}; +- uic_mqtt_dotdot_state_updated_state_t state_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_write_attributes_callback) { ++ uic_mqtt_dotdot_window_covering_state_t window_covering_new_state = {}; ++ uic_mqtt_dotdot_window_covering_updated_state_t window_covering_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- state_new_state, +- state_new_updated_state ++ window_covering_new_state, ++ window_covering_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -107520,17 +105873,17 @@ static inline bool uic_mqtt_dotdot_state_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_state_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_window_covering_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_state_force_read_attributes_callback) { +- uic_mqtt_dotdot_state_updated_state_t state_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_window_covering_force_read_attributes_callback) { ++ uic_mqtt_dotdot_window_covering_updated_state_t window_covering_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- state_force_update ++ window_covering_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -107538,8 +105891,8 @@ static inline bool uic_mqtt_dotdot_state_force_read_attributes_is_supported( + return false; + } + +-// Publishing Supported Commands for State Cluster +-void uic_mqtt_dotdot_state_publish_supported_commands( ++// Publishing Supported Commands for WindowCovering Cluster ++void uic_mqtt_dotdot_window_covering_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -107548,51 +105901,58 @@ void uic_mqtt_dotdot_state_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_state_remove_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_up_or_open_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("Remove")"; ++ ss << R"("UpOrOpen")"; + } +- if (uic_mqtt_dotdot_state_remove_offline_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_down_or_close_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("RemoveOffline")"; ++ ss << R"("DownOrClose")"; + } +- if (uic_mqtt_dotdot_state_discover_neighbors_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_stop_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("DiscoverNeighbors")"; ++ ss << R"("Stop")"; + } +- if (uic_mqtt_dotdot_state_interview_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_go_to_lift_value_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("Interview")"; ++ ss << R"("GoToLiftValue")"; + } +- if (uic_mqtt_dotdot_state_discover_security_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_go_to_lift_percentage_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("DiscoverSecurity")"; ++ ss << R"("GoToLiftPercentage")"; + } +- if (uic_mqtt_dotdot_state_enable_nls_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_go_to_tilt_value_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("EnableNls")"; ++ ss << R"("GoToTiltValue")"; ++ } ++ if (uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GoToTiltPercentage")"; + } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_state_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_window_covering_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107601,7 +105961,7 @@ void uic_mqtt_dotdot_state_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_state_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_window_covering_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107611,8 +105971,8 @@ void uic_mqtt_dotdot_state_publish_supported_commands( + + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); +- +- topic += "/State/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/WindowCovering/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -107623,8 +105983,8 @@ void uic_mqtt_dotdot_state_publish_supported_commands( + // There are no supported commands, but make sure we publish some + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- +- attributes_topic += "/State/Attributes"; ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/WindowCovering/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107635,13 +105995,14 @@ void uic_mqtt_dotdot_state_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for State Cluster +-void uic_mqtt_dotdot_state_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for WindowCovering Cluster ++void uic_mqtt_dotdot_window_covering_publish_empty_supported_commands( + const dotdot_unid_t unid +- ) ++ , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/State/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/WindowCovering/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107651,10 +106012,10 @@ void uic_mqtt_dotdot_state_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for Binding Cluster +-void uic_mqtt_dotdot_binding_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for BarrierControl Cluster ++void uic_mqtt_dotdot_barrier_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/Binding/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/BarrierControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -107671,13 +106032,13 @@ void uic_mqtt_dotdot_binding_publish_cluster_revision(const char* base_topic, ui + true); + } + +-// Unretain Cluster Revision for Binding Cluster +-void uic_mqtt_dotdot_binding_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for BarrierControl Cluster ++void uic_mqtt_dotdot_barrier_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/Binding/Attributes/ClusterRevision"; ++ + "/BarrierControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -107687,68 +106048,16 @@ void uic_mqtt_dotdot_binding_unretain_cluster_revision(const char* base_topic) + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_binding_bind_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- const char* cluster_name_value; +- memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); +- const char* destination_unid_value; +- memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; +- memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); +- for (const auto& callback: uic_mqtt_dotdot_binding_bind_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- cluster_name_value, +- +- destination_unid_value, +- +- destination_ep_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_binding_unbind_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- const char* cluster_name_value; +- memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); +- const char* destination_unid_value; +- memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; +- memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); +- for (const auto& callback: uic_mqtt_dotdot_binding_unbind_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- cluster_name_value, +- +- destination_unid_value, +- +- destination_ep_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_binding_bind_to_protocol_controller_is_supported( ++static inline bool uic_mqtt_dotdot_barrier_control_go_to_percent_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- const char* cluster_name_value; +- memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_binding_bind_to_protocol_controller_callback) { ++ int8_t percent_open_value; ++ memset(&percent_open_value, 0x00, sizeof(percent_open_value)); ++ for (const auto& callback: uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- cluster_name_value ++ percent_open_value + + ) == SL_STATUS_OK) { + return true; +@@ -107757,16 +106066,12 @@ static inline bool uic_mqtt_dotdot_binding_bind_to_protocol_controller_is_suppor + + return false; + } +-static inline bool uic_mqtt_dotdot_binding_unbind_from_protocol_controller_is_supported( ++static inline bool uic_mqtt_dotdot_barrier_control_stop_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- const char* cluster_name_value; +- memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); +- for (const auto& callback: uic_mqtt_dotdot_binding_unbind_from_protocol_controller_callback) { ++ for (const auto& callback: uic_mqtt_dotdot_barrier_control_stop_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- cluster_name_value + + ) == SL_STATUS_OK) { + return true; +@@ -107776,20 +106081,20 @@ static inline bool uic_mqtt_dotdot_binding_unbind_from_protocol_controller_is_su + return false; + } + +-static inline bool uic_mqtt_dotdot_binding_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_barrier_control_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_binding_write_attributes_callback) { +- uic_mqtt_dotdot_binding_state_t binding_new_state = {}; +- uic_mqtt_dotdot_binding_updated_state_t binding_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_barrier_control_write_attributes_callback) { ++ uic_mqtt_dotdot_barrier_control_state_t barrier_control_new_state = {}; ++ uic_mqtt_dotdot_barrier_control_updated_state_t barrier_control_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- binding_new_state, +- binding_new_updated_state ++ barrier_control_new_state, ++ barrier_control_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -107797,17 +106102,17 @@ static inline bool uic_mqtt_dotdot_binding_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_binding_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_barrier_control_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_binding_force_read_attributes_callback) { +- uic_mqtt_dotdot_binding_updated_state_t binding_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_barrier_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_barrier_control_updated_state_t barrier_control_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- binding_force_update ++ barrier_control_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -107815,8 +106120,8 @@ static inline bool uic_mqtt_dotdot_binding_force_read_attributes_is_supported( + return false; + } + +-// Publishing Supported Commands for Binding Cluster +-void uic_mqtt_dotdot_binding_publish_supported_commands( ++// Publishing Supported Commands for BarrierControl Cluster ++void uic_mqtt_dotdot_barrier_control_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -107825,37 +106130,23 @@ void uic_mqtt_dotdot_binding_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_binding_bind_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Bind")"; +- } +- if (uic_mqtt_dotdot_binding_unbind_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Unbind")"; +- } +- if (uic_mqtt_dotdot_binding_bind_to_protocol_controller_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_barrier_control_go_to_percent_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("BindToProtocolController")"; ++ ss << R"("GoToPercent")"; + } +- if (uic_mqtt_dotdot_binding_unbind_from_protocol_controller_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_barrier_control_stop_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("UnbindFromProtocolController")"; ++ ss << R"("Stop")"; + } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_binding_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_barrier_control_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107864,7 +106155,7 @@ void uic_mqtt_dotdot_binding_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_binding_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_barrier_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -107875,7 +106166,7 @@ void uic_mqtt_dotdot_binding_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Binding/SupportedCommands"; ++ topic += "/BarrierControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -107887,7 +106178,7 @@ void uic_mqtt_dotdot_binding_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Binding/Attributes"; ++ attributes_topic += "/BarrierControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107898,14 +106189,14 @@ void uic_mqtt_dotdot_binding_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for Binding Cluster +-void uic_mqtt_dotdot_binding_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for BarrierControl Cluster ++void uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Binding/SupportedCommands"; ++ topic += "/BarrierControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -107915,10 +106206,10 @@ void uic_mqtt_dotdot_binding_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for SystemMetrics Cluster +-void uic_mqtt_dotdot_system_metrics_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for PumpConfigurationAndControl Cluster ++void uic_mqtt_dotdot_pump_configuration_and_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/SystemMetrics/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/PumpConfigurationAndControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -107935,13 +106226,13 @@ void uic_mqtt_dotdot_system_metrics_publish_cluster_revision(const char* base_to + true); + } + +-// Unretain Cluster Revision for SystemMetrics Cluster +-void uic_mqtt_dotdot_system_metrics_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for PumpConfigurationAndControl Cluster ++void uic_mqtt_dotdot_pump_configuration_and_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/SystemMetrics/Attributes/ClusterRevision"; ++ + "/PumpConfigurationAndControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -107952,20 +106243,20 @@ void uic_mqtt_dotdot_system_metrics_unretain_cluster_revision(const char* base_t + } + + +-static inline bool uic_mqtt_dotdot_system_metrics_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_system_metrics_write_attributes_callback) { +- uic_mqtt_dotdot_system_metrics_state_t system_metrics_new_state = {}; +- uic_mqtt_dotdot_system_metrics_updated_state_t system_metrics_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_callback) { ++ uic_mqtt_dotdot_pump_configuration_and_control_state_t pump_configuration_and_control_new_state = {}; ++ uic_mqtt_dotdot_pump_configuration_and_control_updated_state_t pump_configuration_and_control_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- system_metrics_new_state, +- system_metrics_new_updated_state ++ pump_configuration_and_control_new_state, ++ pump_configuration_and_control_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -107973,17 +106264,17 @@ static inline bool uic_mqtt_dotdot_system_metrics_write_attributes_is_supported( + return false; + } + +-static inline bool uic_mqtt_dotdot_system_metrics_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_system_metrics_force_read_attributes_callback) { +- uic_mqtt_dotdot_system_metrics_updated_state_t system_metrics_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_pump_configuration_and_control_updated_state_t pump_configuration_and_control_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- system_metrics_force_update ++ pump_configuration_and_control_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -107991,8 +106282,8 @@ static inline bool uic_mqtt_dotdot_system_metrics_force_read_attributes_is_suppo + return false; + } + +-// Publishing Supported Commands for SystemMetrics Cluster +-void uic_mqtt_dotdot_system_metrics_publish_supported_commands( ++// Publishing Supported Commands for PumpConfigurationAndControl Cluster ++void uic_mqtt_dotdot_pump_configuration_and_control_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -108003,7 +106294,7 @@ void uic_mqtt_dotdot_system_metrics_publish_supported_commands( + // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_system_metrics_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_pump_configuration_and_control_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108012,7 +106303,7 @@ void uic_mqtt_dotdot_system_metrics_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_system_metrics_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_pump_configuration_and_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108022,8 +106313,8 @@ void uic_mqtt_dotdot_system_metrics_publish_supported_commands( + + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); +- +- topic += "/SystemMetrics/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PumpConfigurationAndControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -108034,8 +106325,8 @@ void uic_mqtt_dotdot_system_metrics_publish_supported_commands( + // There are no supported commands, but make sure we publish some + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- +- attributes_topic += "/SystemMetrics/Attributes"; ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/PumpConfigurationAndControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108046,13 +106337,14 @@ void uic_mqtt_dotdot_system_metrics_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for SystemMetrics Cluster +-void uic_mqtt_dotdot_system_metrics_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for PumpConfigurationAndControl Cluster ++void uic_mqtt_dotdot_pump_configuration_and_control_publish_empty_supported_commands( + const dotdot_unid_t unid +- ) ++ , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/SystemMetrics/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PumpConfigurationAndControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108062,10 +106354,10 @@ void uic_mqtt_dotdot_system_metrics_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for ApplicationMonitoring Cluster +-void uic_mqtt_dotdot_application_monitoring_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for Thermostat Cluster ++void uic_mqtt_dotdot_thermostat_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/ApplicationMonitoring/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/Thermostat/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -108082,13 +106374,13 @@ void uic_mqtt_dotdot_application_monitoring_publish_cluster_revision(const char* + true); + } + +-// Unretain Cluster Revision for ApplicationMonitoring Cluster +-void uic_mqtt_dotdot_application_monitoring_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for Thermostat Cluster ++void uic_mqtt_dotdot_thermostat_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/ApplicationMonitoring/Attributes/ClusterRevision"; ++ + "/Thermostat/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -108098,29 +106390,77 @@ void uic_mqtt_dotdot_application_monitoring_unretain_cluster_revision(const char + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_application_monitoring_log_entry_is_supported( ++static inline bool uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- const char* timestamp_value; +- memset(×tamp_value, 0x00, sizeof(timestamp_value)); +- LoggingLevelEnum log_level_value; +- memset(&log_level_value, 0x00, sizeof(log_level_value)); +- const char* log_tag_value; +- memset(&log_tag_value, 0x00, sizeof(log_tag_value)); +- const char* log_message_value; +- memset(&log_message_value, 0x00, sizeof(log_message_value)); +- for (const auto& callback: uic_mqtt_dotdot_application_monitoring_log_entry_callback) { ++ SetpointRaiseOrLowerMode mode_value; ++ memset(&mode_value, 0x00, sizeof(mode_value)); ++ int8_t amount_value; ++ memset(&amount_value, 0x00, sizeof(amount_value)); ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- timestamp_value, ++ mode_value, + +- log_level_value, ++ amount_value + +- log_tag_value, ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t number_of_transitions_value; ++ memset(&number_of_transitions_value, 0x00, sizeof(number_of_transitions_value)); ++ uint8_t day_of_week_value; ++ memset(&day_of_week_value, 0x00, sizeof(day_of_week_value)); ++ uint8_t mode_value; ++ memset(&mode_value, 0x00, sizeof(mode_value)); ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ number_of_transitions_value, + +- log_message_value ++ day_of_week_value, ++ ++ mode_value, ++ ++ 0, nullptr ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_thermostat_set_weekly_schedule_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t number_of_transitions_value; ++ memset(&number_of_transitions_value, 0x00, sizeof(number_of_transitions_value)); ++ uint8_t day_of_week_value; ++ memset(&day_of_week_value, 0x00, sizeof(day_of_week_value)); ++ uint8_t mode_value; ++ memset(&mode_value, 0x00, sizeof(mode_value)); ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_set_weekly_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ number_of_transitions_value, ++ ++ day_of_week_value, ++ ++ mode_value, + ++ 0, nullptr ++ + ) == SL_STATUS_OK) { + return true; + } +@@ -108128,21 +106468,109 @@ static inline bool uic_mqtt_dotdot_application_monitoring_log_entry_is_supported + + return false; + } ++static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t time_of_day_value; ++ memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); ++ uint8_t relay_status_value; ++ memset(&relay_status_value, 0x00, sizeof(relay_status_value)); ++ int16_t local_temperature_value; ++ memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); ++ int8_t humidity_percentage_value; ++ memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); ++ int16_t set_point_value; ++ memset(&set_point_value, 0x00, sizeof(set_point_value)); ++ int16_t unread_entries_value; ++ memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ time_of_day_value, ++ ++ relay_status_value, ++ ++ local_temperature_value, ++ ++ humidity_percentage_value, ++ ++ set_point_value, ++ ++ unread_entries_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_application_monitoring_write_attributes_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_thermostat_get_weekly_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_application_monitoring_write_attributes_callback) { +- uic_mqtt_dotdot_application_monitoring_state_t application_monitoring_new_state = {}; +- uic_mqtt_dotdot_application_monitoring_updated_state_t application_monitoring_new_updated_state = {}; ++ uint8_t days_to_return_value; ++ memset(&days_to_return_value, 0x00, sizeof(days_to_return_value)); ++ uint8_t mode_to_return_value; ++ memset(&mode_to_return_value, 0x00, sizeof(mode_to_return_value)); ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_get_weekly_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ days_to_return_value, ++ ++ mode_to_return_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_thermostat_clear_weekly_schedule_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_clear_weekly_schedule_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_get_relay_status_log_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_thermostat_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_write_attributes_callback) { ++ uic_mqtt_dotdot_thermostat_state_t thermostat_new_state = {}; ++ uic_mqtt_dotdot_thermostat_updated_state_t thermostat_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- application_monitoring_new_state, +- application_monitoring_new_updated_state ++ thermostat_new_state, ++ thermostat_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -108150,17 +106578,17 @@ static inline bool uic_mqtt_dotdot_application_monitoring_write_attributes_is_su + return false; + } + +-static inline bool uic_mqtt_dotdot_application_monitoring_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_thermostat_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_application_monitoring_force_read_attributes_callback) { +- uic_mqtt_dotdot_application_monitoring_updated_state_t application_monitoring_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_force_read_attributes_callback) { ++ uic_mqtt_dotdot_thermostat_updated_state_t thermostat_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- application_monitoring_force_update ++ thermostat_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -108168,8 +106596,8 @@ static inline bool uic_mqtt_dotdot_application_monitoring_force_read_attributes_ + return false; + } + +-// Publishing Supported Commands for ApplicationMonitoring Cluster +-void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( ++// Publishing Supported Commands for Thermostat Cluster ++void uic_mqtt_dotdot_thermostat_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -108178,16 +106606,58 @@ void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_application_monitoring_log_entry_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_thermostat_setpoint_raise_or_lower_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } + first_command = false; +- ss << R"("LogEntry")"; ++ ss << R"("SetpointRaiseOrLower")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_get_weekly_schedule_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetWeeklyScheduleResponse")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_set_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetWeeklySchedule")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetRelayStatusLogResponse")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_get_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetWeeklySchedule")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_clear_weekly_schedule_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ClearWeeklySchedule")"; ++ } ++ if (uic_mqtt_dotdot_thermostat_get_relay_status_log_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetRelayStatusLog")"; + } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_application_monitoring_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_thermostat_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108196,7 +106666,7 @@ void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_application_monitoring_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_thermostat_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108206,8 +106676,8 @@ void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( + + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); +- +- topic += "/ApplicationMonitoring/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Thermostat/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -108218,8 +106688,8 @@ void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( + // There are no supported commands, but make sure we publish some + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- +- attributes_topic += "/ApplicationMonitoring/Attributes"; ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/Thermostat/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108230,13 +106700,14 @@ void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for ApplicationMonitoring Cluster +-void uic_mqtt_dotdot_application_monitoring_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for Thermostat Cluster ++void uic_mqtt_dotdot_thermostat_publish_empty_supported_commands( + const dotdot_unid_t unid +- ) ++ , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ApplicationMonitoring/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Thermostat/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108246,10 +106717,10 @@ void uic_mqtt_dotdot_application_monitoring_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for NameAndLocation Cluster +-void uic_mqtt_dotdot_name_and_location_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for FanControl Cluster ++void uic_mqtt_dotdot_fan_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/NameAndLocation/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/FanControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -108266,13 +106737,13 @@ void uic_mqtt_dotdot_name_and_location_publish_cluster_revision(const char* base + true); + } + +-// Unretain Cluster Revision for NameAndLocation Cluster +-void uic_mqtt_dotdot_name_and_location_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for FanControl Cluster ++void uic_mqtt_dotdot_fan_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/NameAndLocation/Attributes/ClusterRevision"; ++ + "/FanControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -108283,20 +106754,20 @@ void uic_mqtt_dotdot_name_and_location_unretain_cluster_revision(const char* bas + } + + +-static inline bool uic_mqtt_dotdot_name_and_location_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_fan_control_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_name_and_location_write_attributes_callback) { +- uic_mqtt_dotdot_name_and_location_state_t name_and_location_new_state = {}; +- uic_mqtt_dotdot_name_and_location_updated_state_t name_and_location_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_fan_control_write_attributes_callback) { ++ uic_mqtt_dotdot_fan_control_state_t fan_control_new_state = {}; ++ uic_mqtt_dotdot_fan_control_updated_state_t fan_control_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- name_and_location_new_state, +- name_and_location_new_updated_state ++ fan_control_new_state, ++ fan_control_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -108304,17 +106775,17 @@ static inline bool uic_mqtt_dotdot_name_and_location_write_attributes_is_support + return false; + } + +-static inline bool uic_mqtt_dotdot_name_and_location_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_fan_control_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_name_and_location_force_read_attributes_callback) { +- uic_mqtt_dotdot_name_and_location_updated_state_t name_and_location_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_fan_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_fan_control_updated_state_t fan_control_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- name_and_location_force_update ++ fan_control_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -108322,8 +106793,8 @@ static inline bool uic_mqtt_dotdot_name_and_location_force_read_attributes_is_su + return false; + } + +-// Publishing Supported Commands for NameAndLocation Cluster +-void uic_mqtt_dotdot_name_and_location_publish_supported_commands( ++// Publishing Supported Commands for FanControl Cluster ++void uic_mqtt_dotdot_fan_control_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -108334,7 +106805,7 @@ void uic_mqtt_dotdot_name_and_location_publish_supported_commands( + // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_name_and_location_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_fan_control_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108343,7 +106814,7 @@ void uic_mqtt_dotdot_name_and_location_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_name_and_location_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_fan_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108354,7 +106825,7 @@ void uic_mqtt_dotdot_name_and_location_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/NameAndLocation/SupportedCommands"; ++ topic += "/FanControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -108366,7 +106837,7 @@ void uic_mqtt_dotdot_name_and_location_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/NameAndLocation/Attributes"; ++ attributes_topic += "/FanControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108377,14 +106848,14 @@ void uic_mqtt_dotdot_name_and_location_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for NameAndLocation Cluster +-void uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for FanControl Cluster ++void uic_mqtt_dotdot_fan_control_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/NameAndLocation/SupportedCommands"; ++ topic += "/FanControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108394,10 +106865,10 @@ void uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for ConfigurationParameters Cluster +-void uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for DehumidificationControl Cluster ++void uic_mqtt_dotdot_dehumidification_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/ConfigurationParameters/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/DehumidificationControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -108414,13 +106885,13 @@ void uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(const cha + true); + } + +-// Unretain Cluster Revision for ConfigurationParameters Cluster +-void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for DehumidificationControl Cluster ++void uic_mqtt_dotdot_dehumidification_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/ConfigurationParameters/Attributes/ClusterRevision"; ++ + "/DehumidificationControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -108430,97 +106901,21 @@ void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const ch + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t parameter_id_value; +- memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- parameter_id_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_configuration_parameters_set_parameter_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t parameter_id_value; +- memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); +- int64_t value_value; +- memset(&value_value, 0x00, sizeof(value_value)); +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- parameter_id_value, +- +- value_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} +-static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- uint16_t first_parameter_id_value; +- memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- uint16_t last_parameter_id_value; +- memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- first_parameter_id_value, +- +- last_parameter_id_value +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} + +-static inline bool uic_mqtt_dotdot_configuration_parameters_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_dehumidification_control_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_write_attributes_callback) { +- uic_mqtt_dotdot_configuration_parameters_state_t configuration_parameters_new_state = {}; +- uic_mqtt_dotdot_configuration_parameters_updated_state_t configuration_parameters_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_dehumidification_control_write_attributes_callback) { ++ uic_mqtt_dotdot_dehumidification_control_state_t dehumidification_control_new_state = {}; ++ uic_mqtt_dotdot_dehumidification_control_updated_state_t dehumidification_control_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- configuration_parameters_new_state, +- configuration_parameters_new_updated_state ++ dehumidification_control_new_state, ++ dehumidification_control_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -108528,17 +106923,17 @@ static inline bool uic_mqtt_dotdot_configuration_parameters_write_attributes_is_ + return false; + } + +-static inline bool uic_mqtt_dotdot_configuration_parameters_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_dehumidification_control_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback) { +- uic_mqtt_dotdot_configuration_parameters_updated_state_t configuration_parameters_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_dehumidification_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_dehumidification_control_updated_state_t dehumidification_control_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- configuration_parameters_force_update ++ dehumidification_control_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -108546,8 +106941,8 @@ static inline bool uic_mqtt_dotdot_configuration_parameters_force_read_attribute + return false; + } + +-// Publishing Supported Commands for ConfigurationParameters Cluster +-void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( ++// Publishing Supported Commands for DehumidificationControl Cluster ++void uic_mqtt_dotdot_dehumidification_control_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -108556,37 +106951,9 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_configuration_parameters_discover_parameter_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("DiscoverParameter")"; +- } +- if (uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("DefaultResetAllParameters")"; +- } +- if (uic_mqtt_dotdot_configuration_parameters_set_parameter_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetParameter")"; +- } +- if (uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("DiscoverParameterRange")"; +- } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_configuration_parameters_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_dehumidification_control_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108595,7 +106962,7 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_configuration_parameters_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_dehumidification_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108606,7 +106973,7 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ConfigurationParameters/SupportedCommands"; ++ topic += "/DehumidificationControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -108618,7 +106985,7 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/ConfigurationParameters/Attributes"; ++ attributes_topic += "/DehumidificationControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108629,14 +106996,14 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for ConfigurationParameters Cluster +-void uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for DehumidificationControl Cluster ++void uic_mqtt_dotdot_dehumidification_control_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/ConfigurationParameters/SupportedCommands"; ++ topic += "/DehumidificationControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108646,10 +107013,10 @@ void uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for ProtocolController-NetworkManagement Cluster +-void uic_mqtt_dotdot_protocol_controller_network_management_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for ThermostatUserInterfaceConfiguration Cluster ++void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/ProtocolController/NetworkManagement/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/ThermostatUserInterfaceConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -108666,13 +107033,13 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_cluster_revi + true); + } + +-// Unretain Cluster Revision for ProtocolController-NetworkManagement Cluster +-void uic_mqtt_dotdot_protocol_controller_network_management_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for ThermostatUserInterfaceConfiguration Cluster ++void uic_mqtt_dotdot_thermostat_user_interface_configuration_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/ProtocolController/NetworkManagement/Attributes/ClusterRevision"; ++ + "/ThermostatUserInterfaceConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -108682,35 +107049,21 @@ void uic_mqtt_dotdot_protocol_controller_network_management_unretain_cluster_rev + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_protocol_controller_network_management_write_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- +- return false; +-} + +-static inline bool uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback) { +- uic_mqtt_dotdot_protocol_controller_network_management_state_t protocol_controller_network_management_new_state = {}; +- uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t protocol_controller_network_management_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_callback) { ++ uic_mqtt_dotdot_thermostat_user_interface_configuration_state_t thermostat_user_interface_configuration_new_state = {}; ++ uic_mqtt_dotdot_thermostat_user_interface_configuration_updated_state_t thermostat_user_interface_configuration_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- protocol_controller_network_management_new_state, +- protocol_controller_network_management_new_updated_state ++ thermostat_user_interface_configuration_new_state, ++ thermostat_user_interface_configuration_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -108718,17 +107071,17 @@ static inline bool uic_mqtt_dotdot_protocol_controller_network_management_write_ + return false; + } + +-static inline bool uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback) { +- uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t protocol_controller_network_management_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_callback) { ++ uic_mqtt_dotdot_thermostat_user_interface_configuration_updated_state_t thermostat_user_interface_configuration_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- protocol_controller_network_management_force_update ++ thermostat_user_interface_configuration_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -108736,8 +107089,8 @@ static inline bool uic_mqtt_dotdot_protocol_controller_network_management_force_ + return false; + } + +-// Publishing Supported Commands for ProtocolController-NetworkManagement Cluster +-void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_commands( ++// Publishing Supported Commands for ThermostatUserInterfaceConfiguration Cluster ++void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -108746,16 +107099,9 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_co + ss.str(""); + + // check if there is callback for each command +- if (uic_mqtt_dotdot_protocol_controller_network_management_write_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("Write")"; +- } + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_thermostat_user_interface_configuration_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108764,7 +107110,7 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_co + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_thermostat_user_interface_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -108774,8 +107120,8 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_co + + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); +- +- topic += "/ProtocolController/NetworkManagement/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ThermostatUserInterfaceConfiguration/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -108786,8 +107132,8 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_co + // There are no supported commands, but make sure we publish some + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- +- attributes_topic += "/ProtocolController/NetworkManagement/Attributes"; ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/ThermostatUserInterfaceConfiguration/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108798,13 +107144,14 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_co + } + } + +-// Publishing empty/no Supported Commands for ProtocolController-NetworkManagement Cluster +-void uic_mqtt_dotdot_protocol_controller_network_management_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for ThermostatUserInterfaceConfiguration Cluster ++void uic_mqtt_dotdot_thermostat_user_interface_configuration_publish_empty_supported_commands( + const dotdot_unid_t unid +- ) ++ , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ProtocolController/NetworkManagement/SupportedCommands"; ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ThermostatUserInterfaceConfiguration/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -108814,10 +107161,10 @@ void uic_mqtt_dotdot_protocol_controller_network_management_publish_empty_suppor + } + } + +-// Publishing Cluster Revision for Descriptor Cluster +-void uic_mqtt_dotdot_descriptor_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for ColorControl Cluster ++void uic_mqtt_dotdot_color_control_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/Descriptor/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/ColorControl/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -108834,13 +107181,13 @@ void uic_mqtt_dotdot_descriptor_publish_cluster_revision(const char* base_topic, + true); + } + +-// Unretain Cluster Revision for Descriptor Cluster +-void uic_mqtt_dotdot_descriptor_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for ColorControl Cluster ++void uic_mqtt_dotdot_color_control_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/Descriptor/Attributes/ClusterRevision"; ++ + "/ColorControl/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -108850,164 +107197,224 @@ void uic_mqtt_dotdot_descriptor_unretain_cluster_revision(const char* base_topic + // clang-format off + } + +- +-static inline bool uic_mqtt_dotdot_descriptor_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_color_control_move_to_hue_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_descriptor_write_attributes_callback) { +- uic_mqtt_dotdot_descriptor_state_t descriptor_new_state = {}; +- uic_mqtt_dotdot_descriptor_updated_state_t descriptor_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- descriptor_new_state, +- descriptor_new_updated_state +- ) == SL_STATUS_OK) { ++ int8_t hue_value; ++ memset(&hue_value, 0x00, sizeof(hue_value)); ++ CCDirection direction_value; ++ memset(&direction_value, 0x00, sizeof(direction_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ hue_value, ++ ++ direction_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_descriptor_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_color_control_move_hue_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_descriptor_force_read_attributes_callback) { +- uic_mqtt_dotdot_descriptor_updated_state_t descriptor_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- descriptor_force_update +- ) == SL_STATUS_OK) { ++ CCMoveMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int8_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for Descriptor Cluster +-void uic_mqtt_dotdot_descriptor_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_color_control_step_hue_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_descriptor_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ CCStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int8_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int8_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_step_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_descriptor_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_move_to_saturation_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int8_t saturation_value; ++ memset(&saturation_value, 0x00, sizeof(saturation_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_saturation_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ saturation_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("ForceReadAttributes")"; + } + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Descriptor/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/Descriptor/Attributes"; +- +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ return false; + } +- +-// Publishing empty/no Supported Commands for Descriptor Cluster +-void uic_mqtt_dotdot_descriptor_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) ++static inline bool uic_mqtt_dotdot_color_control_move_saturation_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/Descriptor/SupportedCommands"; +- +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); ++ CCMoveMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int8_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_saturation_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } + } +-} + +-// Publishing Cluster Revision for UnifyFanControl Cluster +-void uic_mqtt_dotdot_unify_fan_control_publish_cluster_revision(const char* base_topic, uint16_t value) +-{ +- std::string cluster_topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string pub_topic_des = cluster_topic + "/Desired"; +- std::string payload = std::string(R"({"value": )") +- + std::to_string(value) + std::string("}"); +- uic_mqtt_publish(pub_topic_des.c_str(), +- payload.c_str(), +- payload.size(), +- true); +- // Publish Reported +- std::string pub_topic_rep = cluster_topic + "/Reported"; +- uic_mqtt_publish(pub_topic_rep.c_str(), +- payload.c_str(), +- payload.size(), +- true); ++ return false; + } +- +-// Unretain Cluster Revision for UnifyFanControl Cluster +-void uic_mqtt_dotdot_unify_fan_control_unretain_cluster_revision(const char* base_topic) ++static inline bool uic_mqtt_dotdot_color_control_step_saturation_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) + { +- // clang-format on +- std::string cluster_topic +- = std::string(base_topic) +- + "/UnifyFanControl/Attributes/ClusterRevision"; +- // Publish Desired +- std::string desired_topic = cluster_topic + "/Desired"; +- uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +- // Publish Reported +- std::string reported_topic = cluster_topic + "/Reported"; +- uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); +- // clang-format off +-} ++ CCStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int8_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int8_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_step_saturation_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + +-static inline bool uic_mqtt_dotdot_unify_fan_control_set_fan_mode_is_supported( ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- ZWaveFanModeEnum fan_mode_value; +- memset(&fan_mode_value, 0x00, sizeof(fan_mode_value)); +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback) { ++ int8_t hue_value; ++ memset(&hue_value, 0x00, sizeof(hue_value)); ++ int8_t saturation_value; ++ memset(&saturation_value, 0x00, sizeof(saturation_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK + , +- fan_mode_value ++ hue_value, ++ ++ saturation_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value + + ) == SL_STATUS_OK) { + return true; +@@ -109016,12 +107423,32 @@ static inline bool uic_mqtt_dotdot_unify_fan_control_set_fan_mode_is_supported( + + return false; + } +-static inline bool uic_mqtt_dotdot_unify_fan_control_turn_off_is_supported( ++static inline bool uic_mqtt_dotdot_color_control_move_to_color_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_turn_off_callback) { ++ int16_t colorx_value; ++ memset(&colorx_value, 0x00, sizeof(colorx_value)); ++ int16_t colory_value; ++ memset(&colory_value, 0x00, sizeof(colory_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_color_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ colorx_value, ++ ++ colory_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value + + ) == SL_STATUS_OK) { + return true; +@@ -109030,82 +107457,571 @@ static inline bool uic_mqtt_dotdot_unify_fan_control_turn_off_is_supported( + + return false; + } +- +-static inline bool uic_mqtt_dotdot_unify_fan_control_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_color_control_move_color_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_write_attributes_callback) { +- uic_mqtt_dotdot_unify_fan_control_state_t unify_fan_control_new_state = {}; +- uic_mqtt_dotdot_unify_fan_control_updated_state_t unify_fan_control_new_updated_state = {}; +- +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_fan_control_new_state, +- unify_fan_control_new_updated_state +- ) == SL_STATUS_OK) { ++ int16_t ratex_value; ++ memset(&ratex_value, 0x00, sizeof(ratex_value)); ++ int16_t ratey_value; ++ memset(&ratey_value, 0x00, sizeof(ratey_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_color_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ ratex_value, ++ ++ ratey_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-static inline bool uic_mqtt_dotdot_unify_fan_control_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_color_control_step_color_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_unify_fan_control_updated_state_t unify_fan_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_fan_control_force_update +- ) == SL_STATUS_OK) { ++ int16_t stepx_value; ++ memset(&stepx_value, 0x00, sizeof(stepx_value)); ++ int16_t stepy_value; ++ memset(&stepy_value, 0x00, sizeof(stepy_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_step_color_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ stepx_value, ++ ++ stepy_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { + return true; + } + } ++ + return false; + } +- +-// Publishing Supported Commands for UnifyFanControl Cluster +-void uic_mqtt_dotdot_unify_fan_control_publish_supported_commands( ++static inline bool uic_mqtt_dotdot_color_control_move_to_color_temperature_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_unify_fan_control_set_fan_mode_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ int16_t color_temperature_mireds_value; ++ memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ color_temperature_mireds_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("SetFanMode")"; + } +- if (uic_mqtt_dotdot_unify_fan_control_turn_off_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t enhanced_hue_value; ++ memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); ++ CCDirection direction_value; ++ memset(&direction_value, 0x00, sizeof(direction_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ enhanced_hue_value, ++ ++ direction_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("TurnOff")"; + } + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_unify_fan_control_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CCMoveMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int16_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; + } +- first_command = false; +- ss << R"("WriteAttributes")"; + } + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_unify_fan_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_enhanced_step_hue_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CCStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int16_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_step_hue_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t enhanced_hue_value; ++ memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); ++ int8_t saturation_value; ++ memset(&saturation_value, 0x00, sizeof(saturation_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ enhanced_hue_value, ++ ++ saturation_value, ++ ++ transition_time_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_color_loop_set_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t update_flags_value; ++ memset(&update_flags_value, 0x00, sizeof(update_flags_value)); ++ ColorLoopSetAction action_value; ++ memset(&action_value, 0x00, sizeof(action_value)); ++ CCColorLoopDirection direction_value; ++ memset(&direction_value, 0x00, sizeof(direction_value)); ++ int16_t time_value; ++ memset(&time_value, 0x00, sizeof(time_value)); ++ int16_t start_hue_value; ++ memset(&start_hue_value, 0x00, sizeof(start_hue_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_color_loop_set_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ update_flags_value, ++ ++ action_value, ++ ++ direction_value, ++ ++ time_value, ++ ++ start_hue_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_stop_move_step_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_stop_move_step_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_move_color_temperature_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CCMoveMode move_mode_value; ++ memset(&move_mode_value, 0x00, sizeof(move_mode_value)); ++ int16_t rate_value; ++ memset(&rate_value, 0x00, sizeof(rate_value)); ++ uint8_t * color_temperature_minimum_mireds_value; ++ memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); ++ uint8_t * color_temperature_maximum_mireds_value; ++ memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_move_color_temperature_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ move_mode_value, ++ ++ rate_value, ++ ++ color_temperature_minimum_mireds_value, ++ ++ color_temperature_maximum_mireds_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_color_control_step_color_temperature_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CCStepMode step_mode_value; ++ memset(&step_mode_value, 0x00, sizeof(step_mode_value)); ++ int16_t step_size_value; ++ memset(&step_size_value, 0x00, sizeof(step_size_value)); ++ int16_t transition_time_value; ++ memset(&transition_time_value, 0x00, sizeof(transition_time_value)); ++ uint8_t * color_temperature_minimum_mireds_value; ++ memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); ++ uint8_t * color_temperature_maximum_mireds_value; ++ memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); ++ uint8_t options_mask_value; ++ memset(&options_mask_value, 0x00, sizeof(options_mask_value)); ++ uint8_t options_override_value; ++ memset(&options_override_value, 0x00, sizeof(options_override_value)); ++ for (const auto& callback: uic_mqtt_dotdot_color_control_step_color_temperature_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ step_mode_value, ++ ++ step_size_value, ++ ++ transition_time_value, ++ ++ color_temperature_minimum_mireds_value, ++ ++ color_temperature_maximum_mireds_value, ++ ++ options_mask_value, ++ ++ options_override_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_color_control_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_color_control_write_attributes_callback) { ++ uic_mqtt_dotdot_color_control_state_t color_control_new_state = {}; ++ uic_mqtt_dotdot_color_control_updated_state_t color_control_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ color_control_new_state, ++ color_control_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_color_control_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_color_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_color_control_updated_state_t color_control_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ color_control_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ColorControl Cluster ++void uic_mqtt_dotdot_color_control_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_color_control_move_to_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_step_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StepHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_to_saturation_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToSaturation")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_saturation_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveSaturation")"; ++ } ++ if (uic_mqtt_dotdot_color_control_step_saturation_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StepSaturation")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToHueAndSaturation")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_to_color_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToColor")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_color_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveColor")"; ++ } ++ if (uic_mqtt_dotdot_color_control_step_color_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StepColor")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_to_color_temperature_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveToColorTemperature")"; ++ } ++ if (uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("EnhancedMoveToHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("EnhancedMoveHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_enhanced_step_hue_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("EnhancedStepHue")"; ++ } ++ if (uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("EnhancedMoveToHueAndSaturation")"; ++ } ++ if (uic_mqtt_dotdot_color_control_color_loop_set_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ColorLoopSet")"; ++ } ++ if (uic_mqtt_dotdot_color_control_stop_move_step_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StopMoveStep")"; ++ } ++ if (uic_mqtt_dotdot_color_control_move_color_temperature_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("MoveColorTemperature")"; ++ } ++ if (uic_mqtt_dotdot_color_control_step_color_temperature_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StepColorTemperature")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_color_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_color_control_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -109116,7 +108032,7 @@ void uic_mqtt_dotdot_unify_fan_control_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyFanControl/SupportedCommands"; ++ topic += "/ColorControl/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -109128,7 +108044,7 @@ void uic_mqtt_dotdot_unify_fan_control_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/UnifyFanControl/Attributes"; ++ attributes_topic += "/ColorControl/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -109139,14 +108055,14 @@ void uic_mqtt_dotdot_unify_fan_control_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for UnifyFanControl Cluster +-void uic_mqtt_dotdot_unify_fan_control_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for ColorControl Cluster ++void uic_mqtt_dotdot_color_control_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyFanControl/SupportedCommands"; ++ topic += "/ColorControl/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -109156,10 +108072,10 @@ void uic_mqtt_dotdot_unify_fan_control_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for UnifyThermostat Cluster +-void uic_mqtt_dotdot_unify_thermostat_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for BallastConfiguration Cluster ++void uic_mqtt_dotdot_ballast_configuration_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/UnifyThermostat/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/BallastConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -109176,13 +108092,13 @@ void uic_mqtt_dotdot_unify_thermostat_publish_cluster_revision(const char* base_ + true); + } + +-// Unretain Cluster Revision for UnifyThermostat Cluster +-void uic_mqtt_dotdot_unify_thermostat_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for BallastConfiguration Cluster ++void uic_mqtt_dotdot_ballast_configuration_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/UnifyThermostat/Attributes/ClusterRevision"; ++ + "/BallastConfiguration/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -109193,20 +108109,20 @@ void uic_mqtt_dotdot_unify_thermostat_unretain_cluster_revision(const char* base + } + + +-static inline bool uic_mqtt_dotdot_unify_thermostat_write_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_ballast_configuration_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_write_attributes_callback) { +- uic_mqtt_dotdot_unify_thermostat_state_t unify_thermostat_new_state = {}; +- uic_mqtt_dotdot_unify_thermostat_updated_state_t unify_thermostat_new_updated_state = {}; ++ for (const auto& callback: uic_mqtt_dotdot_ballast_configuration_write_attributes_callback) { ++ uic_mqtt_dotdot_ballast_configuration_state_t ballast_configuration_new_state = {}; ++ uic_mqtt_dotdot_ballast_configuration_updated_state_t ballast_configuration_new_updated_state = {}; + + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_thermostat_new_state, +- unify_thermostat_new_updated_state ++ ballast_configuration_new_state, ++ ballast_configuration_new_updated_state + ) == SL_STATUS_OK) { + return true; + } +@@ -109214,17 +108130,17 @@ static inline bool uic_mqtt_dotdot_unify_thermostat_write_attributes_is_supporte + return false; + } + +-static inline bool uic_mqtt_dotdot_unify_thermostat_force_read_attributes_is_supported( ++static inline bool uic_mqtt_dotdot_ballast_configuration_force_read_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback) { +- uic_mqtt_dotdot_unify_thermostat_updated_state_t unify_thermostat_force_update = {0}; ++ for (const auto& callback: uic_mqtt_dotdot_ballast_configuration_force_read_attributes_callback) { ++ uic_mqtt_dotdot_ballast_configuration_updated_state_t ballast_configuration_force_update = {0}; + if (callback( + unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_thermostat_force_update ++ ballast_configuration_force_update + ) == SL_STATUS_OK) { + return true; + } +@@ -109232,8 +108148,8 @@ static inline bool uic_mqtt_dotdot_unify_thermostat_force_read_attributes_is_sup + return false; + } + +-// Publishing Supported Commands for UnifyThermostat Cluster +-void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( ++// Publishing Supported Commands for BallastConfiguration Cluster ++void uic_mqtt_dotdot_ballast_configuration_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +@@ -109244,7 +108160,7 @@ void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( + // check if there is callback for each command + + // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_unify_thermostat_write_attributes_is_supported(unid, endpoint_id)) { ++ if(uic_mqtt_dotdot_ballast_configuration_write_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -109253,7 +108169,7 @@ void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( + } + + // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_unify_thermostat_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (uic_mqtt_dotdot_ballast_configuration_force_read_attributes_is_supported(unid, endpoint_id)) { + if (first_command == false) { + ss << ", "; + } +@@ -109264,7 +108180,7 @@ void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( + // Publish supported commands + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyThermostat/SupportedCommands"; ++ topic += "/BallastConfiguration/SupportedCommands"; + std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); + if (first_command == false) { + uic_mqtt_publish(topic.c_str(), +@@ -109276,7 +108192,7 @@ void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( + // SupportedCommands = [] if any attribute has been published for a cluster. + std::string attributes_topic = "ucl/by-unid/" + std::string(unid); + attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/UnifyThermostat/Attributes"; ++ attributes_topic += "/BallastConfiguration/Attributes"; + + if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -109287,14 +108203,14 @@ void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( + } + } + +-// Publishing empty/no Supported Commands for UnifyThermostat Cluster +-void uic_mqtt_dotdot_unify_thermostat_publish_empty_supported_commands( ++// Publishing empty/no Supported Commands for BallastConfiguration Cluster ++void uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands( + const dotdot_unid_t unid + , dotdot_endpoint_id_t endpoint_id) + { + std::string topic = "ucl/by-unid/" + std::string(unid); + topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyThermostat/SupportedCommands"; ++ topic += "/BallastConfiguration/SupportedCommands"; + + if (uic_mqtt_count_topics(topic.c_str()) > 0) { + uic_mqtt_publish(topic.c_str(), +@@ -109304,10 +108220,10 @@ void uic_mqtt_dotdot_unify_thermostat_publish_empty_supported_commands( + } + } + +-// Publishing Cluster Revision for UnifyHumidityControl Cluster +-void uic_mqtt_dotdot_unify_humidity_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++// Publishing Cluster Revision for IlluminanceMeasurement Cluster ++void uic_mqtt_dotdot_illuminance_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) + { +- std::string cluster_topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/ClusterRevision"; ++ std::string cluster_topic = std::string(base_topic) + "/IlluminanceMeasurement/Attributes/ClusterRevision"; + // Publish Desired + std::string pub_topic_des = cluster_topic + "/Desired"; + std::string payload = std::string(R"({"value": )") +@@ -109324,13 +108240,13 @@ void uic_mqtt_dotdot_unify_humidity_control_publish_cluster_revision(const char* + true); + } + +-// Unretain Cluster Revision for UnifyHumidityControl Cluster +-void uic_mqtt_dotdot_unify_humidity_control_unretain_cluster_revision(const char* base_topic) ++// Unretain Cluster Revision for IlluminanceMeasurement Cluster ++void uic_mqtt_dotdot_illuminance_measurement_unretain_cluster_revision(const char* base_topic) + { + // clang-format on + std::string cluster_topic + = std::string(base_topic) +- + "/UnifyHumidityControl/Attributes/ClusterRevision"; ++ + "/IlluminanceMeasurement/Attributes/ClusterRevision"; + // Publish Desired + std::string desired_topic = cluster_topic + "/Desired"; + uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); +@@ -109340,209 +108256,7026 @@ void uic_mqtt_dotdot_unify_humidity_control_unretain_cluster_revision(const char + // clang-format off + } + +-static inline bool uic_mqtt_dotdot_unify_humidity_control_mode_set_is_supported( ++ ++static inline bool uic_mqtt_dotdot_illuminance_measurement_write_attributes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- ModeType mode_value; +- memset(&mode_value, 0x00, sizeof(mode_value)); +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_mode_set_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- mode_value +- +- ) == SL_STATUS_OK) { ++ for (const auto& callback: uic_mqtt_dotdot_illuminance_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_illuminance_measurement_state_t illuminance_measurement_new_state = {}; ++ uic_mqtt_dotdot_illuminance_measurement_updated_state_t illuminance_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ illuminance_measurement_new_state, ++ illuminance_measurement_new_updated_state ++ ) == SL_STATUS_OK) { + return true; + } + } ++ return false; ++} + ++static inline bool uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_illuminance_measurement_updated_state_t illuminance_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ illuminance_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + return false; + } +-static inline bool uic_mqtt_dotdot_unify_humidity_control_setpoint_set_is_supported( ++ ++// Publishing Supported Commands for IlluminanceMeasurement Cluster ++void uic_mqtt_dotdot_illuminance_measurement_publish_supported_commands( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- SetpointType type_value; +- memset(&type_value, 0x00, sizeof(type_value)); +- uint8_t precision_value; +- memset(&precision_value, 0x00, sizeof(precision_value)); +- uint8_t scale_value; +- memset(&scale_value, 0x00, sizeof(scale_value)); +- int32_t value_value; +- memset(&value_value, 0x00, sizeof(value_value)); +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback) { +- if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +- , +- type_value, +- +- precision_value, +- +- scale_value, +- +- value_value +- +- ) == SL_STATUS_OK) { ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_illuminance_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_illuminance_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IlluminanceMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/IlluminanceMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for IlluminanceMeasurement Cluster ++void uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IlluminanceMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for IlluminanceLevelSensing Cluster ++void uic_mqtt_dotdot_illuminance_level_sensing_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/IlluminanceLevelSensing/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for IlluminanceLevelSensing Cluster ++void uic_mqtt_dotdot_illuminance_level_sensing_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/IlluminanceLevelSensing/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_callback) { ++ uic_mqtt_dotdot_illuminance_level_sensing_state_t illuminance_level_sensing_new_state = {}; ++ uic_mqtt_dotdot_illuminance_level_sensing_updated_state_t illuminance_level_sensing_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ illuminance_level_sensing_new_state, ++ illuminance_level_sensing_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_callback) { ++ uic_mqtt_dotdot_illuminance_level_sensing_updated_state_t illuminance_level_sensing_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ illuminance_level_sensing_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for IlluminanceLevelSensing Cluster ++void uic_mqtt_dotdot_illuminance_level_sensing_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_illuminance_level_sensing_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_illuminance_level_sensing_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IlluminanceLevelSensing/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/IlluminanceLevelSensing/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for IlluminanceLevelSensing Cluster ++void uic_mqtt_dotdot_illuminance_level_sensing_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IlluminanceLevelSensing/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for TemperatureMeasurement Cluster ++void uic_mqtt_dotdot_temperature_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/TemperatureMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for TemperatureMeasurement Cluster ++void uic_mqtt_dotdot_temperature_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/TemperatureMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_temperature_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_temperature_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_temperature_measurement_state_t temperature_measurement_new_state = {}; ++ uic_mqtt_dotdot_temperature_measurement_updated_state_t temperature_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ temperature_measurement_new_state, ++ temperature_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_temperature_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_temperature_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_temperature_measurement_updated_state_t temperature_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ temperature_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for TemperatureMeasurement Cluster ++void uic_mqtt_dotdot_temperature_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_temperature_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_temperature_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/TemperatureMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/TemperatureMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for TemperatureMeasurement Cluster ++void uic_mqtt_dotdot_temperature_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/TemperatureMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for PressureMeasurement Cluster ++void uic_mqtt_dotdot_pressure_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/PressureMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for PressureMeasurement Cluster ++void uic_mqtt_dotdot_pressure_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/PressureMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_pressure_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_pressure_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_pressure_measurement_state_t pressure_measurement_new_state = {}; ++ uic_mqtt_dotdot_pressure_measurement_updated_state_t pressure_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ pressure_measurement_new_state, ++ pressure_measurement_new_updated_state ++ ) == SL_STATUS_OK) { + return true; + } + } ++ return false; ++} + ++static inline bool uic_mqtt_dotdot_pressure_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_pressure_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_pressure_measurement_updated_state_t pressure_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ pressure_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } + return false; + } +- +-static inline bool uic_mqtt_dotdot_unify_humidity_control_write_attributes_is_supported( ++ ++// Publishing Supported Commands for PressureMeasurement Cluster ++void uic_mqtt_dotdot_pressure_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_pressure_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_pressure_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PressureMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/PressureMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for PressureMeasurement Cluster ++void uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PressureMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for FlowMeasurement Cluster ++void uic_mqtt_dotdot_flow_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/FlowMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for FlowMeasurement Cluster ++void uic_mqtt_dotdot_flow_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/FlowMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_flow_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_flow_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_flow_measurement_state_t flow_measurement_new_state = {}; ++ uic_mqtt_dotdot_flow_measurement_updated_state_t flow_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ flow_measurement_new_state, ++ flow_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_flow_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_flow_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_flow_measurement_updated_state_t flow_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ flow_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for FlowMeasurement Cluster ++void uic_mqtt_dotdot_flow_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_flow_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_flow_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/FlowMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/FlowMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for FlowMeasurement Cluster ++void uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/FlowMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for RelativityHumidity Cluster ++void uic_mqtt_dotdot_relativity_humidity_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/RelativityHumidity/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for RelativityHumidity Cluster ++void uic_mqtt_dotdot_relativity_humidity_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/RelativityHumidity/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_relativity_humidity_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_relativity_humidity_write_attributes_callback) { ++ uic_mqtt_dotdot_relativity_humidity_state_t relativity_humidity_new_state = {}; ++ uic_mqtt_dotdot_relativity_humidity_updated_state_t relativity_humidity_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ relativity_humidity_new_state, ++ relativity_humidity_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_relativity_humidity_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_relativity_humidity_force_read_attributes_callback) { ++ uic_mqtt_dotdot_relativity_humidity_updated_state_t relativity_humidity_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ relativity_humidity_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for RelativityHumidity Cluster ++void uic_mqtt_dotdot_relativity_humidity_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_relativity_humidity_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_relativity_humidity_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/RelativityHumidity/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/RelativityHumidity/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for RelativityHumidity Cluster ++void uic_mqtt_dotdot_relativity_humidity_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/RelativityHumidity/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for OccupancySensing Cluster ++void uic_mqtt_dotdot_occupancy_sensing_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/OccupancySensing/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for OccupancySensing Cluster ++void uic_mqtt_dotdot_occupancy_sensing_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/OccupancySensing/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_occupancy_sensing_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_occupancy_sensing_write_attributes_callback) { ++ uic_mqtt_dotdot_occupancy_sensing_state_t occupancy_sensing_new_state = {}; ++ uic_mqtt_dotdot_occupancy_sensing_updated_state_t occupancy_sensing_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ occupancy_sensing_new_state, ++ occupancy_sensing_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_callback) { ++ uic_mqtt_dotdot_occupancy_sensing_updated_state_t occupancy_sensing_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ occupancy_sensing_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for OccupancySensing Cluster ++void uic_mqtt_dotdot_occupancy_sensing_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_occupancy_sensing_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_occupancy_sensing_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/OccupancySensing/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/OccupancySensing/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for OccupancySensing Cluster ++void uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/OccupancySensing/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for SoilMoisture Cluster ++void uic_mqtt_dotdot_soil_moisture_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/SoilMoisture/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for SoilMoisture Cluster ++void uic_mqtt_dotdot_soil_moisture_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/SoilMoisture/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_soil_moisture_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_soil_moisture_write_attributes_callback) { ++ uic_mqtt_dotdot_soil_moisture_state_t soil_moisture_new_state = {}; ++ uic_mqtt_dotdot_soil_moisture_updated_state_t soil_moisture_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ soil_moisture_new_state, ++ soil_moisture_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_soil_moisture_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_soil_moisture_force_read_attributes_callback) { ++ uic_mqtt_dotdot_soil_moisture_updated_state_t soil_moisture_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ soil_moisture_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for SoilMoisture Cluster ++void uic_mqtt_dotdot_soil_moisture_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_soil_moisture_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_soil_moisture_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/SoilMoisture/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/SoilMoisture/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for SoilMoisture Cluster ++void uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/SoilMoisture/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for PhMeasurement Cluster ++void uic_mqtt_dotdot_ph_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/PhMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for PhMeasurement Cluster ++void uic_mqtt_dotdot_ph_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/PhMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_ph_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_ph_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_ph_measurement_state_t ph_measurement_new_state = {}; ++ uic_mqtt_dotdot_ph_measurement_updated_state_t ph_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ ph_measurement_new_state, ++ ph_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_ph_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_ph_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_ph_measurement_updated_state_t ph_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ ph_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for PhMeasurement Cluster ++void uic_mqtt_dotdot_ph_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_ph_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_ph_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PhMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/PhMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for PhMeasurement Cluster ++void uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PhMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ElectricalConductivityMeasurement Cluster ++void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ElectricalConductivityMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ElectricalConductivityMeasurement Cluster ++void uic_mqtt_dotdot_electrical_conductivity_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ElectricalConductivityMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_electrical_conductivity_measurement_state_t electrical_conductivity_measurement_new_state = {}; ++ uic_mqtt_dotdot_electrical_conductivity_measurement_updated_state_t electrical_conductivity_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ electrical_conductivity_measurement_new_state, ++ electrical_conductivity_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_electrical_conductivity_measurement_updated_state_t electrical_conductivity_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ electrical_conductivity_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ElectricalConductivityMeasurement Cluster ++void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_electrical_conductivity_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_electrical_conductivity_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ElectricalConductivityMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/ElectricalConductivityMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ElectricalConductivityMeasurement Cluster ++void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ElectricalConductivityMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for WindSpeedMeasurement Cluster ++void uic_mqtt_dotdot_wind_speed_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/WindSpeedMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for WindSpeedMeasurement Cluster ++void uic_mqtt_dotdot_wind_speed_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/WindSpeedMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_wind_speed_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_wind_speed_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_wind_speed_measurement_state_t wind_speed_measurement_new_state = {}; ++ uic_mqtt_dotdot_wind_speed_measurement_updated_state_t wind_speed_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ wind_speed_measurement_new_state, ++ wind_speed_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_wind_speed_measurement_updated_state_t wind_speed_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ wind_speed_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for WindSpeedMeasurement Cluster ++void uic_mqtt_dotdot_wind_speed_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_wind_speed_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_wind_speed_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/WindSpeedMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/WindSpeedMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for WindSpeedMeasurement Cluster ++void uic_mqtt_dotdot_wind_speed_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/WindSpeedMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for CarbonMonoxide Cluster ++void uic_mqtt_dotdot_carbon_monoxide_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/CarbonMonoxide/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for CarbonMonoxide Cluster ++void uic_mqtt_dotdot_carbon_monoxide_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/CarbonMonoxide/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_carbon_monoxide_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_carbon_monoxide_write_attributes_callback) { ++ uic_mqtt_dotdot_carbon_monoxide_state_t carbon_monoxide_new_state = {}; ++ uic_mqtt_dotdot_carbon_monoxide_updated_state_t carbon_monoxide_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ carbon_monoxide_new_state, ++ carbon_monoxide_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_callback) { ++ uic_mqtt_dotdot_carbon_monoxide_updated_state_t carbon_monoxide_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ carbon_monoxide_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for CarbonMonoxide Cluster ++void uic_mqtt_dotdot_carbon_monoxide_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_carbon_monoxide_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_carbon_monoxide_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/CarbonMonoxide/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/CarbonMonoxide/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for CarbonMonoxide Cluster ++void uic_mqtt_dotdot_carbon_monoxide_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/CarbonMonoxide/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for CarbonDioxide Cluster ++void uic_mqtt_dotdot_carbon_dioxide_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/CarbonDioxide/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for CarbonDioxide Cluster ++void uic_mqtt_dotdot_carbon_dioxide_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/CarbonDioxide/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_carbon_dioxide_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_carbon_dioxide_write_attributes_callback) { ++ uic_mqtt_dotdot_carbon_dioxide_state_t carbon_dioxide_new_state = {}; ++ uic_mqtt_dotdot_carbon_dioxide_updated_state_t carbon_dioxide_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ carbon_dioxide_new_state, ++ carbon_dioxide_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_callback) { ++ uic_mqtt_dotdot_carbon_dioxide_updated_state_t carbon_dioxide_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ carbon_dioxide_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for CarbonDioxide Cluster ++void uic_mqtt_dotdot_carbon_dioxide_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_carbon_dioxide_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_carbon_dioxide_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/CarbonDioxide/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/CarbonDioxide/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for CarbonDioxide Cluster ++void uic_mqtt_dotdot_carbon_dioxide_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/CarbonDioxide/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for PM25 Cluster ++void uic_mqtt_dotdot_pm25_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/PM25/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for PM25 Cluster ++void uic_mqtt_dotdot_pm25_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/PM25/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_pm25_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_pm25_write_attributes_callback) { ++ uic_mqtt_dotdot_pm25_state_t pm25_new_state = {}; ++ uic_mqtt_dotdot_pm25_updated_state_t pm25_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ pm25_new_state, ++ pm25_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_pm25_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_pm25_force_read_attributes_callback) { ++ uic_mqtt_dotdot_pm25_updated_state_t pm25_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ pm25_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for PM25 Cluster ++void uic_mqtt_dotdot_pm25_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_pm25_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_pm25_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PM25/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/PM25/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for PM25 Cluster ++void uic_mqtt_dotdot_pm25_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/PM25/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for IASZone Cluster ++void uic_mqtt_dotdot_ias_zone_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/IASZone/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for IASZone Cluster ++void uic_mqtt_dotdot_ias_zone_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/IASZone/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; ++ memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); ++ int8_t zoneid_value; ++ memset(&zoneid_value, 0x00, sizeof(zoneid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ enroll_response_code_value, ++ ++ zoneid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint16_t zone_status_value; ++ memset(&zone_status_value, 0x00, sizeof(zone_status_value)); ++ uint8_t extended_status_value; ++ memset(&extended_status_value, 0x00, sizeof(extended_status_value)); ++ int8_t zoneid_value; ++ memset(&zoneid_value, 0x00, sizeof(zoneid_value)); ++ int16_t delay_value; ++ memset(&delay_value, 0x00, sizeof(delay_value)); ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ zone_status_value, ++ ++ extended_status_value, ++ ++ zoneid_value, ++ ++ delay_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ IasZoneType zone_type_value; ++ memset(&zone_type_value, 0x00, sizeof(zone_type_value)); ++ int16_t manufacturer_code_value; ++ memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ zone_type_value, ++ ++ manufacturer_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int8_t test_mode_duration_value; ++ memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); ++ int8_t current_zone_sensitivity_level_value; ++ memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ test_mode_duration_value, ++ ++ current_zone_sensitivity_level_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_ias_zone_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_write_attributes_callback) { ++ uic_mqtt_dotdot_ias_zone_state_t ias_zone_new_state = {}; ++ uic_mqtt_dotdot_ias_zone_updated_state_t ias_zone_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ ias_zone_new_state, ++ ias_zone_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_ias_zone_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_ias_zone_force_read_attributes_callback) { ++ uic_mqtt_dotdot_ias_zone_updated_state_t ias_zone_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ ias_zone_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for IASZone Cluster ++void uic_mqtt_dotdot_ias_zone_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ZoneEnrollResponse")"; ++ } ++ if (uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ZoneStatusChangeNotification")"; ++ } ++ if (uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("InitiateNormalOperationMode")"; ++ } ++ if (uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ZoneEnrollRequest")"; ++ } ++ if (uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("InitiateTestMode")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_ias_zone_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_ias_zone_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IASZone/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/IASZone/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for IASZone Cluster ++void uic_mqtt_dotdot_ias_zone_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IASZone/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for IASWD Cluster ++void uic_mqtt_dotdot_iaswd_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/IASWD/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for IASWD Cluster ++void uic_mqtt_dotdot_iaswd_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/IASWD/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_iaswd_start_warning_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t siren_configuration_value; ++ memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); ++ int16_t warning_duration_value; ++ memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); ++ int8_t strobe_duty_cycle_value; ++ memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); ++ IaswdLevel strobe_level_value; ++ memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); ++ for (const auto& callback: uic_mqtt_dotdot_iaswd_start_warning_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ siren_configuration_value, ++ ++ warning_duration_value, ++ ++ strobe_duty_cycle_value, ++ ++ strobe_level_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_iaswd_squawk_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t squawk_configuration_value; ++ memset(&squawk_configuration_value, 0x00, sizeof(squawk_configuration_value)); ++ for (const auto& callback: uic_mqtt_dotdot_iaswd_squawk_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ squawk_configuration_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_iaswd_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_iaswd_write_attributes_callback) { ++ uic_mqtt_dotdot_iaswd_state_t iaswd_new_state = {}; ++ uic_mqtt_dotdot_iaswd_updated_state_t iaswd_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ iaswd_new_state, ++ iaswd_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_iaswd_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_iaswd_force_read_attributes_callback) { ++ uic_mqtt_dotdot_iaswd_updated_state_t iaswd_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ iaswd_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for IASWD Cluster ++void uic_mqtt_dotdot_iaswd_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_iaswd_start_warning_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("StartWarning")"; ++ } ++ if (uic_mqtt_dotdot_iaswd_squawk_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Squawk")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_iaswd_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_iaswd_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IASWD/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/IASWD/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for IASWD Cluster ++void uic_mqtt_dotdot_iaswd_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/IASWD/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for Metering Cluster ++void uic_mqtt_dotdot_metering_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/Metering/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for Metering Cluster ++void uic_mqtt_dotdot_metering_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/Metering/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_metering_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_metering_write_attributes_callback) { ++ uic_mqtt_dotdot_metering_state_t metering_new_state = {}; ++ uic_mqtt_dotdot_metering_updated_state_t metering_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ metering_new_state, ++ metering_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_metering_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_metering_force_read_attributes_callback) { ++ uic_mqtt_dotdot_metering_updated_state_t metering_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ metering_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for Metering Cluster ++void uic_mqtt_dotdot_metering_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_metering_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_metering_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Metering/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/Metering/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for Metering Cluster ++void uic_mqtt_dotdot_metering_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Metering/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ElectricalMeasurement Cluster ++void uic_mqtt_dotdot_electrical_measurement_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ElectricalMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ElectricalMeasurement Cluster ++void uic_mqtt_dotdot_electrical_measurement_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ElectricalMeasurement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int8_t profile_count_value; ++ memset(&profile_count_value, 0x00, sizeof(profile_count_value)); ++ ProfileIntervalPeriod profile_interval_period_value; ++ memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); ++ int8_t max_number_of_intervals_value; ++ memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ profile_count_value, ++ ++ profile_interval_period_value, ++ ++ max_number_of_intervals_value, ++ ++ 0, nullptr ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_profile_info_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t start_time_value; ++ memset(&start_time_value, 0x00, sizeof(start_time_value)); ++ GetMeasurementProfileResponseStatus status_value; ++ memset(&status_value, 0x00, sizeof(status_value)); ++ ProfileIntervalPeriod profile_interval_period_value; ++ memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); ++ int8_t number_of_intervals_delivered_value; ++ memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); ++ uint8_t attribute_id_value; ++ memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ start_time_value, ++ ++ status_value, ++ ++ profile_interval_period_value, ++ ++ number_of_intervals_delivered_value, ++ ++ attribute_id_value, ++ ++ 0, nullptr ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ uint8_t attributeid_value; ++ memset(&attributeid_value, 0x00, sizeof(attributeid_value)); ++ uint8_t start_time_value; ++ memset(&start_time_value, 0x00, sizeof(start_time_value)); ++ int8_t number_of_intervals_value; ++ memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ attributeid_value, ++ ++ start_time_value, ++ ++ number_of_intervals_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_electrical_measurement_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_write_attributes_callback) { ++ uic_mqtt_dotdot_electrical_measurement_state_t electrical_measurement_new_state = {}; ++ uic_mqtt_dotdot_electrical_measurement_updated_state_t electrical_measurement_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ electrical_measurement_new_state, ++ electrical_measurement_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_electrical_measurement_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_force_read_attributes_callback) { ++ uic_mqtt_dotdot_electrical_measurement_updated_state_t electrical_measurement_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ electrical_measurement_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ElectricalMeasurement Cluster ++void uic_mqtt_dotdot_electrical_measurement_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetProfileInfoResponse")"; ++ } ++ if (uic_mqtt_dotdot_electrical_measurement_get_profile_info_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetProfileInfo")"; ++ } ++ if (uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetMeasurementProfileResponse")"; ++ } ++ if (uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetMeasurementProfile")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_electrical_measurement_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_electrical_measurement_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ElectricalMeasurement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/ElectricalMeasurement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ElectricalMeasurement Cluster ++void uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ElectricalMeasurement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for Diagnostics Cluster ++void uic_mqtt_dotdot_diagnostics_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/Diagnostics/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for Diagnostics Cluster ++void uic_mqtt_dotdot_diagnostics_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/Diagnostics/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_diagnostics_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_diagnostics_write_attributes_callback) { ++ uic_mqtt_dotdot_diagnostics_state_t diagnostics_new_state = {}; ++ uic_mqtt_dotdot_diagnostics_updated_state_t diagnostics_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ diagnostics_new_state, ++ diagnostics_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_diagnostics_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_diagnostics_force_read_attributes_callback) { ++ uic_mqtt_dotdot_diagnostics_updated_state_t diagnostics_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ diagnostics_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for Diagnostics Cluster ++void uic_mqtt_dotdot_diagnostics_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_diagnostics_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_diagnostics_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Diagnostics/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/Diagnostics/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for Diagnostics Cluster ++void uic_mqtt_dotdot_diagnostics_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Diagnostics/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ProtocolController-RFTelemetry Cluster ++void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ProtocolController/RFTelemetry/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ProtocolController-RFTelemetry Cluster ++void uic_mqtt_dotdot_protocol_controller_rf_telemetry_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ProtocolController/RFTelemetry/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* sourceunid_value; ++ memset(&sourceunid_value, 0x00, sizeof(sourceunid_value)); ++ const char* destinationunid_value; ++ memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); ++ bool transmission_successful_value; ++ memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); ++ int16_t transmission_time_ms_value; ++ memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); ++ int8_t tx_powerd_bm_value; ++ memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); ++ int8_t tx_channel_value; ++ memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); ++ int8_t routing_attempts_value; ++ memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); ++ bool route_changed_value; ++ memset(&route_changed_value, 0x00, sizeof(route_changed_value)); ++ TxReportTransmissionSpeed transmission_speed_value; ++ memset(&transmission_speed_value, 0x00, sizeof(transmission_speed_value)); ++ int8_t measured_noise_floord_bm_value; ++ memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); ++ int8_t ackrssi_value; ++ memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); ++ int8_t ack_channel_value; ++ memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); ++ const char* last_route_failed_link_functionalunid_value; ++ memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); ++ const char* last_route_failed_link_non_functionalunid_value; ++ memset(&last_route_failed_link_non_functionalunid_value, 0x00, sizeof(last_route_failed_link_non_functionalunid_value)); ++ int8_t destination_ack_tx_powerd_bm_value; ++ memset(&destination_ack_tx_powerd_bm_value, 0x00, sizeof(destination_ack_tx_powerd_bm_value)); ++ int8_t destination_ack_measuredrssi_value; ++ memset(&destination_ack_measuredrssi_value, 0x00, sizeof(destination_ack_measuredrssi_value)); ++ int8_t destination_ack_measured_noise_floor_value; ++ memset(&destination_ack_measured_noise_floor_value, 0x00, sizeof(destination_ack_measured_noise_floor_value)); ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ sourceunid_value, ++ ++ destinationunid_value, ++ ++ transmission_successful_value, ++ ++ transmission_time_ms_value, ++ ++ tx_powerd_bm_value, ++ ++ tx_channel_value, ++ ++ routing_attempts_value, ++ ++ route_changed_value, ++ ++ transmission_speed_value, ++ ++ measured_noise_floord_bm_value, ++ ++ 0, nullptr, ++ ++ 0, nullptr, ++ ++ ackrssi_value, ++ ++ ack_channel_value, ++ ++ last_route_failed_link_functionalunid_value, ++ ++ last_route_failed_link_non_functionalunid_value, ++ ++ destination_ack_tx_powerd_bm_value, ++ ++ destination_ack_measuredrssi_value, ++ ++ destination_ack_measured_noise_floor_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_callback) { ++ uic_mqtt_dotdot_protocol_controller_rf_telemetry_state_t protocol_controller_rf_telemetry_new_state = {}; ++ uic_mqtt_dotdot_protocol_controller_rf_telemetry_updated_state_t protocol_controller_rf_telemetry_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ protocol_controller_rf_telemetry_new_state, ++ protocol_controller_rf_telemetry_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_callback) { ++ uic_mqtt_dotdot_protocol_controller_rf_telemetry_updated_state_t protocol_controller_rf_telemetry_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ protocol_controller_rf_telemetry_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ProtocolController-RFTelemetry Cluster ++void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("TxReport")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_protocol_controller_rf_telemetry_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_protocol_controller_rf_telemetry_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ ++ topic += "/ProtocolController/RFTelemetry/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ ++ attributes_topic += "/ProtocolController/RFTelemetry/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ProtocolController-RFTelemetry Cluster ++void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ProtocolController/RFTelemetry/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for State Cluster ++void uic_mqtt_dotdot_state_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/State/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for State Cluster ++void uic_mqtt_dotdot_state_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/State/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_state_remove_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_remove_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_state_remove_offline_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_remove_offline_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_state_discover_neighbors_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_discover_neighbors_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_state_interview_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_interview_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_state_discover_security_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_discover_security_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_state_enable_nls_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_enable_nls_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_state_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_write_attributes_callback) { ++ uic_mqtt_dotdot_state_state_t state_new_state = {}; ++ uic_mqtt_dotdot_state_updated_state_t state_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ state_new_state, ++ state_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_state_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_state_force_read_attributes_callback) { ++ uic_mqtt_dotdot_state_updated_state_t state_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ state_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for State Cluster ++void uic_mqtt_dotdot_state_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_state_remove_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Remove")"; ++ } ++ if (uic_mqtt_dotdot_state_remove_offline_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("RemoveOffline")"; ++ } ++ if (uic_mqtt_dotdot_state_discover_neighbors_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DiscoverNeighbors")"; ++ } ++ if (uic_mqtt_dotdot_state_interview_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Interview")"; ++ } ++ if (uic_mqtt_dotdot_state_discover_security_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DiscoverSecurity")"; ++ } ++ if (uic_mqtt_dotdot_state_enable_nls_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("EnableNls")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_state_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_state_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ ++ topic += "/State/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ ++ attributes_topic += "/State/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for State Cluster ++void uic_mqtt_dotdot_state_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/State/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for Binding Cluster ++void uic_mqtt_dotdot_binding_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/Binding/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for Binding Cluster ++void uic_mqtt_dotdot_binding_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/Binding/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_binding_bind_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* cluster_name_value; ++ memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); ++ const char* destination_unid_value; ++ memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); ++ int8_t destination_ep_value; ++ memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); ++ for (const auto& callback: uic_mqtt_dotdot_binding_bind_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ cluster_name_value, ++ ++ destination_unid_value, ++ ++ destination_ep_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_binding_unbind_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* cluster_name_value; ++ memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); ++ const char* destination_unid_value; ++ memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); ++ int8_t destination_ep_value; ++ memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); ++ for (const auto& callback: uic_mqtt_dotdot_binding_unbind_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ cluster_name_value, ++ ++ destination_unid_value, ++ ++ destination_ep_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_binding_bind_to_protocol_controller_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* cluster_name_value; ++ memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_binding_bind_to_protocol_controller_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ cluster_name_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_binding_unbind_from_protocol_controller_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* cluster_name_value; ++ memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); ++ for (const auto& callback: uic_mqtt_dotdot_binding_unbind_from_protocol_controller_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ cluster_name_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_binding_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_binding_write_attributes_callback) { ++ uic_mqtt_dotdot_binding_state_t binding_new_state = {}; ++ uic_mqtt_dotdot_binding_updated_state_t binding_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ binding_new_state, ++ binding_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_binding_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_binding_force_read_attributes_callback) { ++ uic_mqtt_dotdot_binding_updated_state_t binding_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ binding_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for Binding Cluster ++void uic_mqtt_dotdot_binding_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_binding_bind_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Bind")"; ++ } ++ if (uic_mqtt_dotdot_binding_unbind_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Unbind")"; ++ } ++ if (uic_mqtt_dotdot_binding_bind_to_protocol_controller_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("BindToProtocolController")"; ++ } ++ if (uic_mqtt_dotdot_binding_unbind_from_protocol_controller_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("UnbindFromProtocolController")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_binding_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_binding_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Binding/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/Binding/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for Binding Cluster ++void uic_mqtt_dotdot_binding_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Binding/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for SystemMetrics Cluster ++void uic_mqtt_dotdot_system_metrics_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/SystemMetrics/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for SystemMetrics Cluster ++void uic_mqtt_dotdot_system_metrics_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/SystemMetrics/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_system_metrics_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_system_metrics_write_attributes_callback) { ++ uic_mqtt_dotdot_system_metrics_state_t system_metrics_new_state = {}; ++ uic_mqtt_dotdot_system_metrics_updated_state_t system_metrics_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ system_metrics_new_state, ++ system_metrics_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_system_metrics_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_system_metrics_force_read_attributes_callback) { ++ uic_mqtt_dotdot_system_metrics_updated_state_t system_metrics_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ system_metrics_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for SystemMetrics Cluster ++void uic_mqtt_dotdot_system_metrics_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_system_metrics_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_system_metrics_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ ++ topic += "/SystemMetrics/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ ++ attributes_topic += "/SystemMetrics/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for SystemMetrics Cluster ++void uic_mqtt_dotdot_system_metrics_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/SystemMetrics/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ApplicationMonitoring Cluster ++void uic_mqtt_dotdot_application_monitoring_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ApplicationMonitoring/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ApplicationMonitoring Cluster ++void uic_mqtt_dotdot_application_monitoring_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ApplicationMonitoring/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_application_monitoring_log_entry_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* timestamp_value; ++ memset(×tamp_value, 0x00, sizeof(timestamp_value)); ++ LoggingLevelEnum log_level_value; ++ memset(&log_level_value, 0x00, sizeof(log_level_value)); ++ const char* log_tag_value; ++ memset(&log_tag_value, 0x00, sizeof(log_tag_value)); ++ const char* log_message_value; ++ memset(&log_message_value, 0x00, sizeof(log_message_value)); ++ for (const auto& callback: uic_mqtt_dotdot_application_monitoring_log_entry_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ timestamp_value, ++ ++ log_level_value, ++ ++ log_tag_value, ++ ++ log_message_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_application_monitoring_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_application_monitoring_write_attributes_callback) { ++ uic_mqtt_dotdot_application_monitoring_state_t application_monitoring_new_state = {}; ++ uic_mqtt_dotdot_application_monitoring_updated_state_t application_monitoring_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ application_monitoring_new_state, ++ application_monitoring_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_application_monitoring_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_application_monitoring_force_read_attributes_callback) { ++ uic_mqtt_dotdot_application_monitoring_updated_state_t application_monitoring_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ application_monitoring_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ApplicationMonitoring Cluster ++void uic_mqtt_dotdot_application_monitoring_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_application_monitoring_log_entry_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("LogEntry")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_application_monitoring_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_application_monitoring_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ ++ topic += "/ApplicationMonitoring/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ ++ attributes_topic += "/ApplicationMonitoring/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ApplicationMonitoring Cluster ++void uic_mqtt_dotdot_application_monitoring_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ApplicationMonitoring/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for NameAndLocation Cluster ++void uic_mqtt_dotdot_name_and_location_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/NameAndLocation/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for NameAndLocation Cluster ++void uic_mqtt_dotdot_name_and_location_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/NameAndLocation/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_name_and_location_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_name_and_location_write_attributes_callback) { ++ uic_mqtt_dotdot_name_and_location_state_t name_and_location_new_state = {}; ++ uic_mqtt_dotdot_name_and_location_updated_state_t name_and_location_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ name_and_location_new_state, ++ name_and_location_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_name_and_location_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_name_and_location_force_read_attributes_callback) { ++ uic_mqtt_dotdot_name_and_location_updated_state_t name_and_location_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ name_and_location_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for NameAndLocation Cluster ++void uic_mqtt_dotdot_name_and_location_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_name_and_location_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_name_and_location_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/NameAndLocation/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/NameAndLocation/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for NameAndLocation Cluster ++void uic_mqtt_dotdot_name_and_location_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/NameAndLocation/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ConfigurationParameters Cluster ++void uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ConfigurationParameters/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ConfigurationParameters Cluster ++void uic_mqtt_dotdot_configuration_parameters_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ConfigurationParameters/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t parameter_id_value; ++ memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ parameter_id_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_configuration_parameters_set_parameter_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t parameter_id_value; ++ memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); ++ int64_t value_value; ++ memset(&value_value, 0x00, sizeof(value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ parameter_id_value, ++ ++ value_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t first_parameter_id_value; ++ memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); ++ int16_t last_parameter_id_value; ++ memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ first_parameter_id_value, ++ ++ last_parameter_id_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_configuration_parameters_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_write_attributes_callback) { ++ uic_mqtt_dotdot_configuration_parameters_state_t configuration_parameters_new_state = {}; ++ uic_mqtt_dotdot_configuration_parameters_updated_state_t configuration_parameters_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ configuration_parameters_new_state, ++ configuration_parameters_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_configuration_parameters_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback) { ++ uic_mqtt_dotdot_configuration_parameters_updated_state_t configuration_parameters_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ configuration_parameters_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ConfigurationParameters Cluster ++void uic_mqtt_dotdot_configuration_parameters_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_configuration_parameters_discover_parameter_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DiscoverParameter")"; ++ } ++ if (uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DefaultResetAllParameters")"; ++ } ++ if (uic_mqtt_dotdot_configuration_parameters_set_parameter_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetParameter")"; ++ } ++ if (uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DiscoverParameterRange")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_configuration_parameters_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_configuration_parameters_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ConfigurationParameters/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/ConfigurationParameters/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ConfigurationParameters Cluster ++void uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/ConfigurationParameters/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for UserCredential Cluster ++void uic_mqtt_dotdot_user_credential_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/UserCredential/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for UserCredential Cluster ++void uic_mqtt_dotdot_user_credential_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/UserCredential/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_user_credential_add_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_add_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_modify_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_modify_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_add_credential_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_add_credential_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_modify_credential_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_modify_credential_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_credential_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_credential_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_all_users_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_users_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_credential_learn_start_add_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_credential_learn_start_modify_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_credential_learn_stop_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_stop_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_credential_association_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t source_user_uniqueid_value; ++ memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); ++ int16_t source_credential_slot_value; ++ memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); ++ int16_t destination_user_uniqueid_value; ++ memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); ++ int16_t destination_credential_slot_value; ++ memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_association_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value, ++ ++ source_user_uniqueid_value, ++ ++ source_credential_slot_value, ++ ++ destination_user_uniqueid_value, ++ ++ destination_credential_slot_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_get_user_checksum_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_get_credential_checksum_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_credential_checksum_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_get_all_users_checksum_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_set_admin_pin_code_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ const char* pin_code_value; ++ memset(&pin_code_value, 0x00, sizeof(pin_code_value)); ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_code_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_user_credential_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_write_attributes_callback) { ++ uic_mqtt_dotdot_user_credential_state_t user_credential_new_state = {}; ++ uic_mqtt_dotdot_user_credential_updated_state_t user_credential_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ user_credential_new_state, ++ user_credential_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_user_credential_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_user_credential_force_read_attributes_callback) { ++ uic_mqtt_dotdot_user_credential_updated_state_t user_credential_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ user_credential_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for UserCredential Cluster ++void uic_mqtt_dotdot_user_credential_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_user_credential_add_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("AddUser")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_modify_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ModifyUser")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteUser")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_add_credential_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("AddCredential")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_modify_credential_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ModifyCredential")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_credential_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteCredential")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_all_users_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteAllUsers")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_all_credentials_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteAllCredentials")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteAllCredentialsByType")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteAllCredentialsForUser")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeleteAllCredentialsForUserByType")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_credential_learn_start_add_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CredentialLearnStartAdd")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_credential_learn_start_modify_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CredentialLearnStartModify")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_credential_learn_stop_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CredentialLearnStop")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_credential_association_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("CredentialAssociation")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_get_user_checksum_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetUserChecksum")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_get_credential_checksum_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetCredentialChecksum")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_get_all_users_checksum_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("GetAllUsersChecksum")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_set_admin_pin_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetAdminPINCode")"; ++ } ++ if (uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("DeactivateAdminPINCode")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_user_credential_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_user_credential_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UserCredential/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/UserCredential/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for UserCredential Cluster ++void uic_mqtt_dotdot_user_credential_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UserCredential/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for ProtocolController-NetworkManagement Cluster ++void uic_mqtt_dotdot_protocol_controller_network_management_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/ProtocolController/NetworkManagement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for ProtocolController-NetworkManagement Cluster ++void uic_mqtt_dotdot_protocol_controller_network_management_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/ProtocolController/NetworkManagement/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_network_management_write_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback) { ++ uic_mqtt_dotdot_protocol_controller_network_management_state_t protocol_controller_network_management_new_state = {}; ++ uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t protocol_controller_network_management_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ protocol_controller_network_management_new_state, ++ protocol_controller_network_management_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback) { ++ uic_mqtt_dotdot_protocol_controller_network_management_updated_state_t protocol_controller_network_management_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ protocol_controller_network_management_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for ProtocolController-NetworkManagement Cluster ++void uic_mqtt_dotdot_protocol_controller_network_management_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_protocol_controller_network_management_write_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("Write")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ ++ topic += "/ProtocolController/NetworkManagement/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ ++ attributes_topic += "/ProtocolController/NetworkManagement/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for ProtocolController-NetworkManagement Cluster ++void uic_mqtt_dotdot_protocol_controller_network_management_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ ) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ProtocolController/NetworkManagement/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for Descriptor Cluster ++void uic_mqtt_dotdot_descriptor_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/Descriptor/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for Descriptor Cluster ++void uic_mqtt_dotdot_descriptor_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/Descriptor/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_descriptor_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_descriptor_write_attributes_callback) { ++ uic_mqtt_dotdot_descriptor_state_t descriptor_new_state = {}; ++ uic_mqtt_dotdot_descriptor_updated_state_t descriptor_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ descriptor_new_state, ++ descriptor_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_descriptor_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_descriptor_force_read_attributes_callback) { ++ uic_mqtt_dotdot_descriptor_updated_state_t descriptor_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ descriptor_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for Descriptor Cluster ++void uic_mqtt_dotdot_descriptor_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_descriptor_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_descriptor_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Descriptor/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/Descriptor/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for Descriptor Cluster ++void uic_mqtt_dotdot_descriptor_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/Descriptor/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for UnifyFanControl Cluster ++void uic_mqtt_dotdot_unify_fan_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/UnifyFanControl/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for UnifyFanControl Cluster ++void uic_mqtt_dotdot_unify_fan_control_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/UnifyFanControl/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_unify_fan_control_set_fan_mode_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ ZWaveFanModeEnum fan_mode_value; ++ memset(&fan_mode_value, 0x00, sizeof(fan_mode_value)); ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ fan_mode_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_unify_fan_control_turn_off_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_turn_off_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_unify_fan_control_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_write_attributes_callback) { ++ uic_mqtt_dotdot_unify_fan_control_state_t unify_fan_control_new_state = {}; ++ uic_mqtt_dotdot_unify_fan_control_updated_state_t unify_fan_control_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_fan_control_new_state, ++ unify_fan_control_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_unify_fan_control_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_fan_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_unify_fan_control_updated_state_t unify_fan_control_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_fan_control_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for UnifyFanControl Cluster ++void uic_mqtt_dotdot_unify_fan_control_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_unify_fan_control_set_fan_mode_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetFanMode")"; ++ } ++ if (uic_mqtt_dotdot_unify_fan_control_turn_off_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("TurnOff")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_unify_fan_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_unify_fan_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyFanControl/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/UnifyFanControl/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for UnifyFanControl Cluster ++void uic_mqtt_dotdot_unify_fan_control_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyFanControl/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for UnifyThermostat Cluster ++void uic_mqtt_dotdot_unify_thermostat_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/UnifyThermostat/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for UnifyThermostat Cluster ++void uic_mqtt_dotdot_unify_thermostat_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/UnifyThermostat/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++ ++static inline bool uic_mqtt_dotdot_unify_thermostat_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_write_attributes_callback) { ++ uic_mqtt_dotdot_unify_thermostat_state_t unify_thermostat_new_state = {}; ++ uic_mqtt_dotdot_unify_thermostat_updated_state_t unify_thermostat_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_thermostat_new_state, ++ unify_thermostat_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_unify_thermostat_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_thermostat_force_read_attributes_callback) { ++ uic_mqtt_dotdot_unify_thermostat_updated_state_t unify_thermostat_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_thermostat_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for UnifyThermostat Cluster ++void uic_mqtt_dotdot_unify_thermostat_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_unify_thermostat_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_unify_thermostat_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyThermostat/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/UnifyThermostat/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for UnifyThermostat Cluster ++void uic_mqtt_dotdot_unify_thermostat_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyThermostat/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++// Publishing Cluster Revision for UnifyHumidityControl Cluster ++void uic_mqtt_dotdot_unify_humidity_control_publish_cluster_revision(const char* base_topic, uint16_t value) ++{ ++ std::string cluster_topic = std::string(base_topic) + "/UnifyHumidityControl/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string pub_topic_des = cluster_topic + "/Desired"; ++ std::string payload = std::string(R"({"value": )") ++ + std::to_string(value) + std::string("}"); ++ uic_mqtt_publish(pub_topic_des.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++ // Publish Reported ++ std::string pub_topic_rep = cluster_topic + "/Reported"; ++ uic_mqtt_publish(pub_topic_rep.c_str(), ++ payload.c_str(), ++ payload.size(), ++ true); ++} ++ ++// Unretain Cluster Revision for UnifyHumidityControl Cluster ++void uic_mqtt_dotdot_unify_humidity_control_unretain_cluster_revision(const char* base_topic) ++{ ++ // clang-format on ++ std::string cluster_topic ++ = std::string(base_topic) ++ + "/UnifyHumidityControl/Attributes/ClusterRevision"; ++ // Publish Desired ++ std::string desired_topic = cluster_topic + "/Desired"; ++ uic_mqtt_publish(desired_topic.c_str(), NULL, 0, true); ++ // Publish Reported ++ std::string reported_topic = cluster_topic + "/Reported"; ++ uic_mqtt_publish(reported_topic.c_str(), NULL, 0, true); ++ // clang-format off ++} ++ ++static inline bool uic_mqtt_dotdot_unify_humidity_control_mode_set_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ ModeType mode_value; ++ memset(&mode_value, 0x00, sizeof(mode_value)); ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_mode_set_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ mode_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++static inline bool uic_mqtt_dotdot_unify_humidity_control_setpoint_set_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ SetpointType type_value; ++ memset(&type_value, 0x00, sizeof(type_value)); ++ int8_t precision_value; ++ memset(&precision_value, 0x00, sizeof(precision_value)); ++ int8_t scale_value; ++ memset(&scale_value, 0x00, sizeof(scale_value)); ++ int32_t value_value; ++ memset(&value_value, 0x00, sizeof(value_value)); ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback) { ++ if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ type_value, ++ ++ precision_value, ++ ++ scale_value, ++ ++ value_value ++ ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_unify_humidity_control_write_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback) { ++ uic_mqtt_dotdot_unify_humidity_control_state_t unify_humidity_control_new_state = {}; ++ uic_mqtt_dotdot_unify_humidity_control_updated_state_t unify_humidity_control_new_updated_state = {}; ++ ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_humidity_control_new_state, ++ unify_humidity_control_new_updated_state ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++static inline bool uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_is_supported( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback) { ++ uic_mqtt_dotdot_unify_humidity_control_updated_state_t unify_humidity_control_force_update = {0}; ++ if (callback( ++ unid, ++ endpoint_id, ++ UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, ++ unify_humidity_control_force_update ++ ) == SL_STATUS_OK) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++// Publishing Supported Commands for UnifyHumidityControl Cluster ++void uic_mqtt_dotdot_unify_humidity_control_publish_supported_commands( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id) ++{ ++ std::stringstream ss; ++ bool first_command = true; ++ ss.str(""); ++ ++ // check if there is callback for each command ++ if (uic_mqtt_dotdot_unify_humidity_control_mode_set_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ModeSet")"; ++ } ++ if (uic_mqtt_dotdot_unify_humidity_control_setpoint_set_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("SetpointSet")"; ++ } ++ ++ // Check for a WriteAttributes Callback ++ if(uic_mqtt_dotdot_unify_humidity_control_write_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("WriteAttributes")"; ++ } ++ ++ // Check for a ForceReadAttributes Callback ++ if (uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_is_supported(unid, endpoint_id)) { ++ if (first_command == false) { ++ ss << ", "; ++ } ++ first_command = false; ++ ss << R"("ForceReadAttributes")"; ++ } ++ ++ // Publish supported commands ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyHumidityControl/SupportedCommands"; ++ std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); ++ if (first_command == false) { ++ uic_mqtt_publish(topic.c_str(), ++ payload_str.c_str(), ++ payload_str.length(), ++ true); ++ } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { ++ // There are no supported commands, but make sure we publish some ++ // SupportedCommands = [] if any attribute has been published for a cluster. ++ std::string attributes_topic = "ucl/by-unid/" + std::string(unid); ++ attributes_topic += "/ep"+ std::to_string(endpoint_id); ++ attributes_topic += "/UnifyHumidityControl/Attributes"; ++ ++ if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++ } ++} ++ ++// Publishing empty/no Supported Commands for UnifyHumidityControl Cluster ++void uic_mqtt_dotdot_unify_humidity_control_publish_empty_supported_commands( ++ const dotdot_unid_t unid ++ , dotdot_endpoint_id_t endpoint_id) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint_id); ++ topic += "/UnifyHumidityControl/SupportedCommands"; ++ ++ if (uic_mqtt_count_topics(topic.c_str()) > 0) { ++ uic_mqtt_publish(topic.c_str(), ++ EMPTY_VALUE_ARRAY, ++ strlen(EMPTY_VALUE_ARRAY), ++ true); ++ } ++} ++ ++ ++//////////////////////////////////////////////////////////////////////////////// ++// Generated Commands publications functions ++//////////////////////////////////////////////////////////////////////////////// ++/** ++ * @brief Publishes an incoming/generated ResetToFactoryDefaults command for ++ * the Basic cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Basic/GeneratedCommands/ResetToFactoryDefaults ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_basic_publish_generated_reset_to_factory_defaults_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Basic/GeneratedCommands/ResetToFactoryDefaults"; ++ ++ std::string payload = ++ get_json_payload_for_basic_reset_to_factory_defaults_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated Identify command for ++ * the Identify cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/Identify ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_identify_publish_generated_identify_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_identify_command_identify_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Identify/GeneratedCommands/Identify"; ++ ++ std::string payload = ++ get_json_payload_for_identify_identify_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated IdentifyQueryResponse command for ++ * the Identify cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/IdentifyQueryResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_identify_publish_generated_identify_query_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_identify_command_identify_query_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Identify/GeneratedCommands/IdentifyQueryResponse"; ++ ++ std::string payload = ++ get_json_payload_for_identify_identify_query_response_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated IdentifyQuery command for ++ * the Identify cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/IdentifyQuery ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_identify_publish_generated_identify_query_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Identify/GeneratedCommands/IdentifyQuery"; ++ ++ std::string payload = ++ get_json_payload_for_identify_identify_query_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated TriggerEffect command for ++ * the Identify cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/TriggerEffect ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_identify_publish_generated_trigger_effect_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_identify_command_trigger_effect_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Identify/GeneratedCommands/TriggerEffect"; ++ ++ std::string payload = ++ get_json_payload_for_identify_trigger_effect_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddGroup command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroup ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_add_group_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_add_group_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/AddGroup"; ++ ++ std::string payload = ++ get_json_payload_for_groups_add_group_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddGroupResponse command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroupResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_add_group_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_add_group_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/AddGroupResponse"; ++ ++ std::string payload = ++ get_json_payload_for_groups_add_group_response_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated ViewGroup command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/ViewGroup ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_view_group_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_view_group_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/ViewGroup"; ++ ++ std::string payload = ++ get_json_payload_for_groups_view_group_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated ViewGroupResponse command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/ViewGroupResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_view_group_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_view_group_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/ViewGroupResponse"; ++ ++ std::string payload = ++ get_json_payload_for_groups_view_group_response_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated GetGroupMembership command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/GetGroupMembership ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_get_group_membership_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/GetGroupMembership"; ++ ++ std::string payload = ++ get_json_payload_for_groups_get_group_membership_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated GetGroupMembershipResponse command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/GetGroupMembershipResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/GetGroupMembershipResponse"; ++ ++ std::string payload = ++ get_json_payload_for_groups_get_group_membership_response_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated RemoveGroup command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveGroup ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_remove_group_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_remove_group_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/RemoveGroup"; ++ ++ std::string payload = ++ get_json_payload_for_groups_remove_group_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated RemoveGroupResponse command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveGroupResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_remove_group_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_remove_group_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/RemoveGroupResponse"; ++ ++ std::string payload = ++ get_json_payload_for_groups_remove_group_response_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated RemoveAllGroups command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveAllGroups ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_remove_all_groups_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/RemoveAllGroups"; ++ ++ std::string payload = ++ get_json_payload_for_groups_remove_all_groups_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddGroupIfIdentifying command for ++ * the Groups cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroupIfIdentifying ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_groups_publish_generated_add_group_if_identifying_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_groups_command_add_group_if_identifying_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Groups/GeneratedCommands/AddGroupIfIdentifying"; ++ ++ std::string payload = ++ get_json_payload_for_groups_add_group_if_identifying_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddScene command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/AddScene ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_add_scene_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_add_scene_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/AddScene"; ++ ++ std::string payload = ++ get_json_payload_for_scenes_add_scene_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddSceneResponse command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/AddSceneResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_add_scene_response_command( + const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_write_attributes_callback) { +- uic_mqtt_dotdot_unify_humidity_control_state_t unify_humidity_control_new_state = {}; +- uic_mqtt_dotdot_unify_humidity_control_updated_state_t unify_humidity_control_new_updated_state = {}; ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_add_scene_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/AddSceneResponse"; + +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_humidity_control_new_state, +- unify_humidity_control_new_updated_state +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; +-} ++ std::string payload = ++ get_json_payload_for_scenes_add_scene_response_command( ++ fields); + +-static inline bool uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_is_supported( +- const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- for (const auto& callback: uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_callback) { +- uic_mqtt_dotdot_unify_humidity_control_updated_state_t unify_humidity_control_force_update = {0}; +- if (callback( +- unid, +- endpoint_id, +- UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, +- unify_humidity_control_force_update +- ) == SL_STATUS_OK) { +- return true; +- } +- } +- return false; ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); + } +- +-// Publishing Supported Commands for UnifyHumidityControl Cluster +-void uic_mqtt_dotdot_unify_humidity_control_publish_supported_commands( ++/** ++ * @brief Publishes an incoming/generated ViewScene command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/ViewScene ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_view_scene_command( + const dotdot_unid_t unid, +- dotdot_endpoint_id_t endpoint_id) +-{ +- std::stringstream ss; +- bool first_command = true; +- ss.str(""); +- +- // check if there is callback for each command +- if (uic_mqtt_dotdot_unify_humidity_control_mode_set_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ModeSet")"; +- } +- if (uic_mqtt_dotdot_unify_humidity_control_setpoint_set_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("SetpointSet")"; +- } ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_view_scene_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/ViewScene"; + +- // Check for a WriteAttributes Callback +- if(uic_mqtt_dotdot_unify_humidity_control_write_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("WriteAttributes")"; +- } ++ std::string payload = ++ get_json_payload_for_scenes_view_scene_command( ++ fields); + +- // Check for a ForceReadAttributes Callback +- if (uic_mqtt_dotdot_unify_humidity_control_force_read_attributes_is_supported(unid, endpoint_id)) { +- if (first_command == false) { +- ss << ", "; +- } +- first_command = false; +- ss << R"("ForceReadAttributes")"; +- } ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated ViewSceneResponse command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/ViewSceneResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_view_scene_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_view_scene_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/ViewSceneResponse"; + +- // Publish supported commands +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyHumidityControl/SupportedCommands"; +- std::string payload_str("{\"value\": [" + ss.str() + "]" + "}"); +- if (first_command == false) { +- uic_mqtt_publish(topic.c_str(), +- payload_str.c_str(), +- payload_str.length(), +- true); +- } else if (uic_mqtt_count_topics(topic.c_str()) == 0) { +- // There are no supported commands, but make sure we publish some +- // SupportedCommands = [] if any attribute has been published for a cluster. +- std::string attributes_topic = "ucl/by-unid/" + std::string(unid); +- attributes_topic += "/ep"+ std::to_string(endpoint_id); +- attributes_topic += "/UnifyHumidityControl/Attributes"; ++ std::string payload = ++ get_json_payload_for_scenes_view_scene_response_command( ++ fields); + +- if (uic_mqtt_count_topics(attributes_topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } +- } ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); + } ++/** ++ * @brief Publishes an incoming/generated RemoveScene command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveScene ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_remove_scene_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/RemoveScene"; + +-// Publishing empty/no Supported Commands for UnifyHumidityControl Cluster +-void uic_mqtt_dotdot_unify_humidity_control_publish_empty_supported_commands( +- const dotdot_unid_t unid +- , dotdot_endpoint_id_t endpoint_id) +-{ +- std::string topic = "ucl/by-unid/" + std::string(unid); +- topic += "/ep"+ std::to_string(endpoint_id); +- topic += "/UnifyHumidityControl/SupportedCommands"; ++ std::string payload = ++ get_json_payload_for_scenes_remove_scene_command( ++ fields); + +- if (uic_mqtt_count_topics(topic.c_str()) > 0) { +- uic_mqtt_publish(topic.c_str(), +- EMPTY_VALUE_ARRAY, +- strlen(EMPTY_VALUE_ARRAY), +- true); +- } ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); + } ++/** ++ * @brief Publishes an incoming/generated RemoveSceneResponse command for ++ * the Scenes cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveSceneResponse ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_response_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_remove_scene_response_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "Scenes/GeneratedCommands/RemoveSceneResponse"; + ++ std::string payload = ++ get_json_payload_for_scenes_remove_scene_response_command( ++ fields); + +-//////////////////////////////////////////////////////////////////////////////// +-// Generated Commands publications functions +-//////////////////////////////////////////////////////////////////////////////// ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} + /** +- * @brief Publishes an incoming/generated ResetToFactoryDefaults command for +- * the Basic cluster. ++ * @brief Publishes an incoming/generated RemoveAllScenes command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Basic/GeneratedCommands/ResetToFactoryDefaults ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveAllScenes + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_basic_publish_generated_reset_to_factory_defaults_command( ++void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_remove_all_scenes_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Basic/GeneratedCommands/ResetToFactoryDefaults"; ++ topic += "Scenes/GeneratedCommands/RemoveAllScenes"; + + std::string payload = +- get_json_payload_for_basic_reset_to_factory_defaults_command( +- ); ++ get_json_payload_for_scenes_remove_all_scenes_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -109551,11 +115284,11 @@ void uic_mqtt_dotdot_basic_publish_generated_reset_to_factory_defaults_command( + false); + } + /** +- * @brief Publishes an incoming/generated Identify command for +- * the Identify cluster. ++ * @brief Publishes an incoming/generated RemoveAllScenesResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/Identify ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveAllScenesResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109565,19 +115298,19 @@ void uic_mqtt_dotdot_basic_publish_generated_reset_to_factory_defaults_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_identify_publish_generated_identify_command( ++void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_identify_command_identify_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_remove_all_scenes_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Identify/GeneratedCommands/Identify"; ++ topic += "Scenes/GeneratedCommands/RemoveAllScenesResponse"; + + std::string payload = +- get_json_payload_for_identify_identify_command( ++ get_json_payload_for_scenes_remove_all_scenes_response_command( + fields); + + // Publish our command +@@ -109587,11 +115320,11 @@ void uic_mqtt_dotdot_identify_publish_generated_identify_command( + false); + } + /** +- * @brief Publishes an incoming/generated IdentifyQueryResponse command for +- * the Identify cluster. ++ * @brief Publishes an incoming/generated StoreScene command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/IdentifyQueryResponse ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/StoreScene + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109601,19 +115334,19 @@ void uic_mqtt_dotdot_identify_publish_generated_identify_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_identify_publish_generated_identify_query_response_command( ++void uic_mqtt_dotdot_scenes_publish_generated_store_scene_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_identify_command_identify_query_response_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_store_scene_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Identify/GeneratedCommands/IdentifyQueryResponse"; ++ topic += "Scenes/GeneratedCommands/StoreScene"; + + std::string payload = +- get_json_payload_for_identify_identify_query_response_command( ++ get_json_payload_for_scenes_store_scene_command( + fields); + + // Publish our command +@@ -109623,30 +115356,34 @@ void uic_mqtt_dotdot_identify_publish_generated_identify_query_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated IdentifyQuery command for +- * the Identify cluster. ++ * @brief Publishes an incoming/generated StoreSceneResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/IdentifyQuery ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/StoreSceneResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_identify_publish_generated_identify_query_command( ++void uic_mqtt_dotdot_scenes_publish_generated_store_scene_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_scenes_command_store_scene_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Identify/GeneratedCommands/IdentifyQuery"; ++ topic += "Scenes/GeneratedCommands/StoreSceneResponse"; + + std::string payload = +- get_json_payload_for_identify_identify_query_command( +- ); ++ get_json_payload_for_scenes_store_scene_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -109655,11 +115392,11 @@ void uic_mqtt_dotdot_identify_publish_generated_identify_query_command( + false); + } + /** +- * @brief Publishes an incoming/generated TriggerEffect command for +- * the Identify cluster. ++ * @brief Publishes an incoming/generated RecallScene command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Identify/GeneratedCommands/TriggerEffect ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RecallScene + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109669,19 +115406,19 @@ void uic_mqtt_dotdot_identify_publish_generated_identify_query_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_identify_publish_generated_trigger_effect_command( ++void uic_mqtt_dotdot_scenes_publish_generated_recall_scene_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_identify_command_trigger_effect_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_recall_scene_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Identify/GeneratedCommands/TriggerEffect"; ++ topic += "Scenes/GeneratedCommands/RecallScene"; + + std::string payload = +- get_json_payload_for_identify_trigger_effect_command( ++ get_json_payload_for_scenes_recall_scene_command( + fields); + + // Publish our command +@@ -109691,11 +115428,11 @@ void uic_mqtt_dotdot_identify_publish_generated_trigger_effect_command( + false); + } + /** +- * @brief Publishes an incoming/generated AddGroup command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated GetSceneMembership command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroup ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/GetSceneMembership + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109705,19 +115442,19 @@ void uic_mqtt_dotdot_identify_publish_generated_trigger_effect_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_add_group_command( ++void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_add_group_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_get_scene_membership_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/AddGroup"; ++ topic += "Scenes/GeneratedCommands/GetSceneMembership"; + + std::string payload = +- get_json_payload_for_groups_add_group_command( ++ get_json_payload_for_scenes_get_scene_membership_command( + fields); + + // Publish our command +@@ -109727,11 +115464,11 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_command( + false); + } + /** +- * @brief Publishes an incoming/generated AddGroupResponse command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated GetSceneMembershipResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroupResponse ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/GetSceneMembershipResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109741,19 +115478,19 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_add_group_response_command( ++void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_add_group_response_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/AddGroupResponse"; ++ topic += "Scenes/GeneratedCommands/GetSceneMembershipResponse"; + + std::string payload = +- get_json_payload_for_groups_add_group_response_command( ++ get_json_payload_for_scenes_get_scene_membership_response_command( + fields); + + // Publish our command +@@ -109763,11 +115500,11 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ViewGroup command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated EnhancedAddScene command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/ViewGroup ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedAddScene + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109777,19 +115514,19 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_view_group_command( ++void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_view_group_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_enhanced_add_scene_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/ViewGroup"; ++ topic += "Scenes/GeneratedCommands/EnhancedAddScene"; + + std::string payload = +- get_json_payload_for_groups_view_group_command( ++ get_json_payload_for_scenes_enhanced_add_scene_command( + fields); + + // Publish our command +@@ -109799,11 +115536,11 @@ void uic_mqtt_dotdot_groups_publish_generated_view_group_command( + false); + } + /** +- * @brief Publishes an incoming/generated ViewGroupResponse command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated EnhancedAddSceneResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/ViewGroupResponse ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedAddSceneResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109813,19 +115550,19 @@ void uic_mqtt_dotdot_groups_publish_generated_view_group_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_view_group_response_command( ++void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_view_group_response_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_enhanced_add_scene_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/ViewGroupResponse"; ++ topic += "Scenes/GeneratedCommands/EnhancedAddSceneResponse"; + + std::string payload = +- get_json_payload_for_groups_view_group_response_command( ++ get_json_payload_for_scenes_enhanced_add_scene_response_command( + fields); + + // Publish our command +@@ -109835,11 +115572,11 @@ void uic_mqtt_dotdot_groups_publish_generated_view_group_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetGroupMembership command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated EnhancedViewScene command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/GetGroupMembership ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedViewScene + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109849,19 +115586,19 @@ void uic_mqtt_dotdot_groups_publish_generated_view_group_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_command( ++void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_get_group_membership_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_enhanced_view_scene_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/GetGroupMembership"; ++ topic += "Scenes/GeneratedCommands/EnhancedViewScene"; + + std::string payload = +- get_json_payload_for_groups_get_group_membership_command( ++ get_json_payload_for_scenes_enhanced_view_scene_command( + fields); + + // Publish our command +@@ -109871,11 +115608,11 @@ void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetGroupMembershipResponse command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated EnhancedViewSceneResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/GetGroupMembershipResponse ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedViewSceneResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109885,19 +115622,19 @@ void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_response_command( ++void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_enhanced_view_scene_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/GetGroupMembershipResponse"; ++ topic += "Scenes/GeneratedCommands/EnhancedViewSceneResponse"; + + std::string payload = +- get_json_payload_for_groups_get_group_membership_response_command( ++ get_json_payload_for_scenes_enhanced_view_scene_response_command( + fields); + + // Publish our command +@@ -109907,11 +115644,11 @@ void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_response_comm + false); + } + /** +- * @brief Publishes an incoming/generated RemoveGroup command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated CopyScene command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveGroup ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/CopyScene + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109921,19 +115658,19 @@ void uic_mqtt_dotdot_groups_publish_generated_get_group_membership_response_comm + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_remove_group_command( ++void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_remove_group_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_copy_scene_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/RemoveGroup"; ++ topic += "Scenes/GeneratedCommands/CopyScene"; + + std::string payload = +- get_json_payload_for_groups_remove_group_command( ++ get_json_payload_for_scenes_copy_scene_command( + fields); + + // Publish our command +@@ -109943,11 +115680,11 @@ void uic_mqtt_dotdot_groups_publish_generated_remove_group_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveGroupResponse command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated CopySceneResponse command for ++ * the Scenes cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveGroupResponse ++ * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/CopySceneResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109957,19 +115694,19 @@ void uic_mqtt_dotdot_groups_publish_generated_remove_group_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_remove_group_response_command( ++void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_remove_group_response_fields_t *fields ++ const uic_mqtt_dotdot_scenes_command_copy_scene_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/RemoveGroupResponse"; ++ topic += "Scenes/GeneratedCommands/CopySceneResponse"; + + std::string payload = +- get_json_payload_for_groups_remove_group_response_command( ++ get_json_payload_for_scenes_copy_scene_response_command( + fields); + + // Publish our command +@@ -109979,11 +115716,43 @@ void uic_mqtt_dotdot_groups_publish_generated_remove_group_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveAllGroups command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated Off command for ++ * the OnOff cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/Off ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_on_off_publish_generated_off_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "OnOff/GeneratedCommands/Off"; ++ ++ std::string payload = ++ get_json_payload_for_on_off_off_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated On command for ++ * the OnOff cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/RemoveAllGroups ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/On + * + * @param unid The UNID of the node that sent us the command. + * +@@ -109991,17 +115760,17 @@ void uic_mqtt_dotdot_groups_publish_generated_remove_group_response_command( + * + * + */ +-void uic_mqtt_dotdot_groups_publish_generated_remove_all_groups_command( ++void uic_mqtt_dotdot_on_off_publish_generated_on_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/RemoveAllGroups"; ++ topic += "OnOff/GeneratedCommands/On"; + + std::string payload = +- get_json_payload_for_groups_remove_all_groups_command( ++ get_json_payload_for_on_off_on_command( + ); + + // Publish our command +@@ -110011,34 +115780,30 @@ void uic_mqtt_dotdot_groups_publish_generated_remove_all_groups_command( + false); + } + /** +- * @brief Publishes an incoming/generated AddGroupIfIdentifying command for +- * the Groups cluster. ++ * @brief Publishes an incoming/generated Toggle command for ++ * the OnOff cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Groups/GeneratedCommands/AddGroupIfIdentifying ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/Toggle + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_groups_publish_generated_add_group_if_identifying_command( ++void uic_mqtt_dotdot_on_off_publish_generated_toggle_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_groups_command_add_group_if_identifying_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Groups/GeneratedCommands/AddGroupIfIdentifying"; ++ topic += "OnOff/GeneratedCommands/Toggle"; + + std::string payload = +- get_json_payload_for_groups_add_group_if_identifying_command( +- fields); ++ get_json_payload_for_on_off_toggle_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110047,11 +115812,11 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_if_identifying_command( + false); + } + /** +- * @brief Publishes an incoming/generated AddScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated OffWithEffect command for ++ * the OnOff cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/AddScene ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OffWithEffect + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110061,19 +115826,19 @@ void uic_mqtt_dotdot_groups_publish_generated_add_group_if_identifying_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_add_scene_command( ++void uic_mqtt_dotdot_on_off_publish_generated_off_with_effect_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_add_scene_fields_t *fields ++ const uic_mqtt_dotdot_on_off_command_off_with_effect_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/AddScene"; ++ topic += "OnOff/GeneratedCommands/OffWithEffect"; + + std::string payload = +- get_json_payload_for_scenes_add_scene_command( ++ get_json_payload_for_on_off_off_with_effect_command( + fields); + + // Publish our command +@@ -110083,34 +115848,30 @@ void uic_mqtt_dotdot_scenes_publish_generated_add_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated AddSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated OnWithRecallGlobalScene command for ++ * the OnOff cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/AddSceneResponse ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OnWithRecallGlobalScene + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_add_scene_response_command( ++void uic_mqtt_dotdot_on_off_publish_generated_on_with_recall_global_scene_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_add_scene_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/AddSceneResponse"; ++ topic += "OnOff/GeneratedCommands/OnWithRecallGlobalScene"; + + std::string payload = +- get_json_payload_for_scenes_add_scene_response_command( +- fields); ++ get_json_payload_for_on_off_on_with_recall_global_scene_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110119,11 +115880,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_add_scene_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ViewScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated OnWithTimedOff command for ++ * the OnOff cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/ViewScene ++ * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OnWithTimedOff + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110133,19 +115894,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_add_scene_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_view_scene_command( ++void uic_mqtt_dotdot_on_off_publish_generated_on_with_timed_off_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_view_scene_fields_t *fields ++ const uic_mqtt_dotdot_on_off_command_on_with_timed_off_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/ViewScene"; ++ topic += "OnOff/GeneratedCommands/OnWithTimedOff"; + + std::string payload = +- get_json_payload_for_scenes_view_scene_command( ++ get_json_payload_for_on_off_on_with_timed_off_command( + fields); + + // Publish our command +@@ -110155,11 +115916,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_view_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated ViewSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated MoveToLevel command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/ViewSceneResponse ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToLevel + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110169,19 +115930,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_view_scene_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_view_scene_response_command( ++void uic_mqtt_dotdot_level_publish_generated_move_to_level_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_view_scene_response_fields_t *fields ++ const uic_mqtt_dotdot_level_command_move_to_level_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/ViewSceneResponse"; ++ topic += "Level/GeneratedCommands/MoveToLevel"; + + std::string payload = +- get_json_payload_for_scenes_view_scene_response_command( ++ get_json_payload_for_level_move_to_level_command( + fields); + + // Publish our command +@@ -110191,11 +115952,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_view_scene_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated Move command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveScene ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Move + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110205,19 +115966,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_view_scene_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_command( ++void uic_mqtt_dotdot_level_publish_generated_move_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_remove_scene_fields_t *fields ++ const uic_mqtt_dotdot_level_command_move_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/RemoveScene"; ++ topic += "Level/GeneratedCommands/Move"; + + std::string payload = +- get_json_payload_for_scenes_remove_scene_command( ++ get_json_payload_for_level_move_command( + fields); + + // Publish our command +@@ -110227,11 +115988,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated Step command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveSceneResponse ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Step + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110241,19 +116002,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_response_command( ++void uic_mqtt_dotdot_level_publish_generated_step_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_remove_scene_response_fields_t *fields ++ const uic_mqtt_dotdot_level_command_step_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/RemoveSceneResponse"; ++ topic += "Level/GeneratedCommands/Step"; + + std::string payload = +- get_json_payload_for_scenes_remove_scene_response_command( ++ get_json_payload_for_level_step_command( + fields); + + // Publish our command +@@ -110263,11 +116024,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveAllScenes command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated Stop command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveAllScenes ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Stop + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110277,19 +116038,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_scene_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_command( ++void uic_mqtt_dotdot_level_publish_generated_stop_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_remove_all_scenes_fields_t *fields ++ const uic_mqtt_dotdot_level_command_stop_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/RemoveAllScenes"; ++ topic += "Level/GeneratedCommands/Stop"; + + std::string payload = +- get_json_payload_for_scenes_remove_all_scenes_command( ++ get_json_payload_for_level_stop_command( + fields); + + // Publish our command +@@ -110299,11 +116060,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveAllScenesResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated MoveToLevelWithOnOff command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RemoveAllScenesResponse ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToLevelWithOnOff + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110313,19 +116074,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_response_command( ++void uic_mqtt_dotdot_level_publish_generated_move_to_level_with_on_off_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_remove_all_scenes_response_fields_t *fields ++ const uic_mqtt_dotdot_level_command_move_to_level_with_on_off_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/RemoveAllScenesResponse"; ++ topic += "Level/GeneratedCommands/MoveToLevelWithOnOff"; + + std::string payload = +- get_json_payload_for_scenes_remove_all_scenes_response_command( ++ get_json_payload_for_level_move_to_level_with_on_off_command( + fields); + + // Publish our command +@@ -110335,11 +116096,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_response_command + false); + } + /** +- * @brief Publishes an incoming/generated StoreScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated MoveWithOnOff command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/StoreScene ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveWithOnOff + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110349,19 +116110,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_remove_all_scenes_response_command + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_store_scene_command( ++void uic_mqtt_dotdot_level_publish_generated_move_with_on_off_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_store_scene_fields_t *fields ++ const uic_mqtt_dotdot_level_command_move_with_on_off_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/StoreScene"; ++ topic += "Level/GeneratedCommands/MoveWithOnOff"; + + std::string payload = +- get_json_payload_for_scenes_store_scene_command( ++ get_json_payload_for_level_move_with_on_off_command( + fields); + + // Publish our command +@@ -110371,11 +116132,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_store_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated StoreSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated StepWithOnOff command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/StoreSceneResponse ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/StepWithOnOff + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110385,19 +116146,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_store_scene_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_store_scene_response_command( ++void uic_mqtt_dotdot_level_publish_generated_step_with_on_off_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_store_scene_response_fields_t *fields ++ const uic_mqtt_dotdot_level_command_step_with_on_off_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/StoreSceneResponse"; ++ topic += "Level/GeneratedCommands/StepWithOnOff"; + + std::string payload = +- get_json_payload_for_scenes_store_scene_response_command( ++ get_json_payload_for_level_step_with_on_off_command( + fields); + + // Publish our command +@@ -110407,11 +116168,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_store_scene_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated RecallScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated StopWithOnOff command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/RecallScene ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/StopWithOnOff + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110421,19 +116182,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_store_scene_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_recall_scene_command( ++void uic_mqtt_dotdot_level_publish_generated_stop_with_on_off_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_recall_scene_fields_t *fields ++ const uic_mqtt_dotdot_level_command_stop_with_on_off_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/RecallScene"; ++ topic += "Level/GeneratedCommands/StopWithOnOff"; + + std::string payload = +- get_json_payload_for_scenes_recall_scene_command( ++ get_json_payload_for_level_stop_with_on_off_command( + fields); + + // Publish our command +@@ -110443,11 +116204,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_recall_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetSceneMembership command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated MoveToClosestFrequency command for ++ * the Level cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/GetSceneMembership ++ * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToClosestFrequency + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110457,19 +116218,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_recall_scene_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_command( ++void uic_mqtt_dotdot_level_publish_generated_move_to_closest_frequency_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_get_scene_membership_fields_t *fields ++ const uic_mqtt_dotdot_level_command_move_to_closest_frequency_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/GetSceneMembership"; ++ topic += "Level/GeneratedCommands/MoveToClosestFrequency"; + + std::string payload = +- get_json_payload_for_scenes_get_scene_membership_command( ++ get_json_payload_for_level_move_to_closest_frequency_command( + fields); + + // Publish our command +@@ -110479,11 +116240,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetSceneMembershipResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated ResetAlarm command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/GetSceneMembershipResponse ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAlarm + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110493,19 +116254,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_response_command( ++void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t *fields ++ const uic_mqtt_dotdot_alarms_command_reset_alarm_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/GetSceneMembershipResponse"; ++ topic += "Alarms/GeneratedCommands/ResetAlarm"; + + std::string payload = +- get_json_payload_for_scenes_get_scene_membership_response_command( ++ get_json_payload_for_alarms_reset_alarm_command( + fields); + + // Publish our command +@@ -110515,11 +116276,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_response_comm + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedAddScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated Alarm command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedAddScene ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/Alarm + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110529,19 +116290,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_get_scene_membership_response_comm + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_command( ++void uic_mqtt_dotdot_alarms_publish_generated_alarm_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_enhanced_add_scene_fields_t *fields ++ const uic_mqtt_dotdot_alarms_command_alarm_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/EnhancedAddScene"; ++ topic += "Alarms/GeneratedCommands/Alarm"; + + std::string payload = +- get_json_payload_for_scenes_enhanced_add_scene_command( ++ get_json_payload_for_alarms_alarm_command( + fields); + + // Publish our command +@@ -110551,34 +116312,30 @@ void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedAddSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated ResetAllAlarms command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedAddSceneResponse ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAllAlarms + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_response_command( ++void uic_mqtt_dotdot_alarms_publish_generated_reset_all_alarms_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_enhanced_add_scene_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/EnhancedAddSceneResponse"; ++ topic += "Alarms/GeneratedCommands/ResetAllAlarms"; + + std::string payload = +- get_json_payload_for_scenes_enhanced_add_scene_response_command( +- fields); ++ get_json_payload_for_alarms_reset_all_alarms_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110587,11 +116344,11 @@ void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_response_comman + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedViewScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated GetAlarmResponse command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedViewScene ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/GetAlarmResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110601,19 +116358,19 @@ void uic_mqtt_dotdot_scenes_publish_generated_enhanced_add_scene_response_comman + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_command( ++void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_enhanced_view_scene_fields_t *fields ++ const uic_mqtt_dotdot_alarms_command_get_alarm_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/EnhancedViewScene"; ++ topic += "Alarms/GeneratedCommands/GetAlarmResponse"; + + std::string payload = +- get_json_payload_for_scenes_enhanced_view_scene_command( ++ get_json_payload_for_alarms_get_alarm_response_command( + fields); + + // Publish our command +@@ -110623,34 +116380,30 @@ void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedViewSceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated GetAlarm command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/EnhancedViewSceneResponse ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/GetAlarm + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_response_command( ++void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_enhanced_view_scene_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/EnhancedViewSceneResponse"; ++ topic += "Alarms/GeneratedCommands/GetAlarm"; + + std::string payload = +- get_json_payload_for_scenes_enhanced_view_scene_response_command( +- fields); ++ get_json_payload_for_alarms_get_alarm_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110659,34 +116412,30 @@ void uic_mqtt_dotdot_scenes_publish_generated_enhanced_view_scene_response_comma + false); + } + /** +- * @brief Publishes an incoming/generated CopyScene command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated ResetAlarmLog command for ++ * the Alarms cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/CopyScene ++ * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAlarmLog + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_command( ++void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_log_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_copy_scene_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/CopyScene"; ++ topic += "Alarms/GeneratedCommands/ResetAlarmLog"; + + std::string payload = +- get_json_payload_for_scenes_copy_scene_command( +- fields); ++ get_json_payload_for_alarms_reset_alarm_log_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110695,34 +116444,30 @@ void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_command( + false); + } + /** +- * @brief Publishes an incoming/generated CopySceneResponse command for +- * the Scenes cluster. ++ * @brief Publishes an incoming/generated CheckIn command for ++ * the PollControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Scenes/GeneratedCommands/CopySceneResponse ++ * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/CheckIn + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_response_command( ++void uic_mqtt_dotdot_poll_control_publish_generated_check_in_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_scenes_command_copy_scene_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Scenes/GeneratedCommands/CopySceneResponse"; ++ topic += "PollControl/GeneratedCommands/CheckIn"; + + std::string payload = +- get_json_payload_for_scenes_copy_scene_response_command( +- fields); ++ get_json_payload_for_poll_control_check_in_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110731,30 +116476,34 @@ void uic_mqtt_dotdot_scenes_publish_generated_copy_scene_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated Off command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated CheckInResponse command for ++ * the PollControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/Off ++ * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/CheckInResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_off_command( ++void uic_mqtt_dotdot_poll_control_publish_generated_check_in_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_poll_control_command_check_in_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/Off"; ++ topic += "PollControl/GeneratedCommands/CheckInResponse"; + + std::string payload = +- get_json_payload_for_on_off_off_command( +- ); ++ get_json_payload_for_poll_control_check_in_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110763,11 +116512,11 @@ void uic_mqtt_dotdot_on_off_publish_generated_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated On command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated FastPollStop command for ++ * the PollControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/On ++ * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/FastPollStop + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110775,17 +116524,17 @@ void uic_mqtt_dotdot_on_off_publish_generated_off_command( + * + * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_on_command( ++void uic_mqtt_dotdot_poll_control_publish_generated_fast_poll_stop_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/On"; ++ topic += "PollControl/GeneratedCommands/FastPollStop"; + + std::string payload = +- get_json_payload_for_on_off_on_command( ++ get_json_payload_for_poll_control_fast_poll_stop_command( + ); + + // Publish our command +@@ -110795,30 +116544,34 @@ void uic_mqtt_dotdot_on_off_publish_generated_on_command( + false); + } + /** +- * @brief Publishes an incoming/generated Toggle command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated SetLongPollInterval command for ++ * the PollControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/Toggle ++ * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/SetLongPollInterval + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_toggle_command( ++void uic_mqtt_dotdot_poll_control_publish_generated_set_long_poll_interval_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_poll_control_command_set_long_poll_interval_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/Toggle"; ++ topic += "PollControl/GeneratedCommands/SetLongPollInterval"; + + std::string payload = +- get_json_payload_for_on_off_toggle_command( +- ); ++ get_json_payload_for_poll_control_set_long_poll_interval_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110827,11 +116580,11 @@ void uic_mqtt_dotdot_on_off_publish_generated_toggle_command( + false); + } + /** +- * @brief Publishes an incoming/generated OffWithEffect command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated SetShortPollInterval command for ++ * the PollControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OffWithEffect ++ * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/SetShortPollInterval + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110841,19 +116594,19 @@ void uic_mqtt_dotdot_on_off_publish_generated_toggle_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_off_with_effect_command( ++void uic_mqtt_dotdot_poll_control_publish_generated_set_short_poll_interval_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_on_off_command_off_with_effect_fields_t *fields ++ const uic_mqtt_dotdot_poll_control_command_set_short_poll_interval_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/OffWithEffect"; ++ topic += "PollControl/GeneratedCommands/SetShortPollInterval"; + + std::string payload = +- get_json_payload_for_on_off_off_with_effect_command( ++ get_json_payload_for_poll_control_set_short_poll_interval_command( + fields); + + // Publish our command +@@ -110863,30 +116616,34 @@ void uic_mqtt_dotdot_on_off_publish_generated_off_with_effect_command( + false); + } + /** +- * @brief Publishes an incoming/generated OnWithRecallGlobalScene command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated LockDoor command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OnWithRecallGlobalScene ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/LockDoor + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_on_with_recall_global_scene_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_lock_door_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/OnWithRecallGlobalScene"; ++ topic += "DoorLock/GeneratedCommands/LockDoor"; + + std::string payload = +- get_json_payload_for_on_off_on_with_recall_global_scene_command( +- ); ++ get_json_payload_for_door_lock_lock_door_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -110895,11 +116652,11 @@ void uic_mqtt_dotdot_on_off_publish_generated_on_with_recall_global_scene_comman + false); + } + /** +- * @brief Publishes an incoming/generated OnWithTimedOff command for +- * the OnOff cluster. ++ * @brief Publishes an incoming/generated LockDoorResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/OnOff/GeneratedCommands/OnWithTimedOff ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/LockDoorResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110909,19 +116666,19 @@ void uic_mqtt_dotdot_on_off_publish_generated_on_with_recall_global_scene_comman + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_on_off_publish_generated_on_with_timed_off_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_on_off_command_on_with_timed_off_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_lock_door_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "OnOff/GeneratedCommands/OnWithTimedOff"; ++ topic += "DoorLock/GeneratedCommands/LockDoorResponse"; + + std::string payload = +- get_json_payload_for_on_off_on_with_timed_off_command( ++ get_json_payload_for_door_lock_lock_door_response_command( + fields); + + // Publish our command +@@ -110931,11 +116688,11 @@ void uic_mqtt_dotdot_on_off_publish_generated_on_with_timed_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToLevel command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated UnlockDoor command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToLevel ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockDoor + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110945,19 +116702,19 @@ void uic_mqtt_dotdot_on_off_publish_generated_on_with_timed_off_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_move_to_level_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_move_to_level_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_unlock_door_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/MoveToLevel"; ++ topic += "DoorLock/GeneratedCommands/UnlockDoor"; + + std::string payload = +- get_json_payload_for_level_move_to_level_command( ++ get_json_payload_for_door_lock_unlock_door_command( + fields); + + // Publish our command +@@ -110967,11 +116724,11 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_level_command( + false); + } + /** +- * @brief Publishes an incoming/generated Move command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated UnlockDoorResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Move ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockDoorResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -110981,19 +116738,19 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_level_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_move_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_move_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_unlock_door_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/Move"; ++ topic += "DoorLock/GeneratedCommands/UnlockDoorResponse"; + + std::string payload = +- get_json_payload_for_level_move_command( ++ get_json_payload_for_door_lock_unlock_door_response_command( + fields); + + // Publish our command +@@ -111003,11 +116760,11 @@ void uic_mqtt_dotdot_level_publish_generated_move_command( + false); + } + /** +- * @brief Publishes an incoming/generated Step command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated Toggle command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Step ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/Toggle + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111017,19 +116774,19 @@ void uic_mqtt_dotdot_level_publish_generated_move_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_step_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_toggle_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_step_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_toggle_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/Step"; ++ topic += "DoorLock/GeneratedCommands/Toggle"; + + std::string payload = +- get_json_payload_for_level_step_command( ++ get_json_payload_for_door_lock_toggle_command( + fields); + + // Publish our command +@@ -111039,11 +116796,11 @@ void uic_mqtt_dotdot_level_publish_generated_step_command( + false); + } + /** +- * @brief Publishes an incoming/generated Stop command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated ToggleResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/Stop ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ToggleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111053,19 +116810,19 @@ void uic_mqtt_dotdot_level_publish_generated_step_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_stop_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_toggle_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_stop_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_toggle_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/Stop"; ++ topic += "DoorLock/GeneratedCommands/ToggleResponse"; + + std::string payload = +- get_json_payload_for_level_stop_command( ++ get_json_payload_for_door_lock_toggle_response_command( + fields); + + // Publish our command +@@ -111075,11 +116832,11 @@ void uic_mqtt_dotdot_level_publish_generated_stop_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToLevelWithOnOff command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated UnlockWithTimeout command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToLevelWithOnOff ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockWithTimeout + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111089,19 +116846,19 @@ void uic_mqtt_dotdot_level_publish_generated_stop_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_move_to_level_with_on_off_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_move_to_level_with_on_off_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/MoveToLevelWithOnOff"; ++ topic += "DoorLock/GeneratedCommands/UnlockWithTimeout"; + + std::string payload = +- get_json_payload_for_level_move_to_level_with_on_off_command( ++ get_json_payload_for_door_lock_unlock_with_timeout_command( + fields); + + // Publish our command +@@ -111111,11 +116868,11 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_level_with_on_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveWithOnOff command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated UnlockWithTimeoutResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveWithOnOff ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockWithTimeoutResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111125,19 +116882,19 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_level_with_on_off_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_move_with_on_off_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_move_with_on_off_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/MoveWithOnOff"; ++ topic += "DoorLock/GeneratedCommands/UnlockWithTimeoutResponse"; + + std::string payload = +- get_json_payload_for_level_move_with_on_off_command( ++ get_json_payload_for_door_lock_unlock_with_timeout_response_command( + fields); + + // Publish our command +@@ -111147,11 +116904,11 @@ void uic_mqtt_dotdot_level_publish_generated_move_with_on_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated StepWithOnOff command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated GetLogRecord command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/StepWithOnOff ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetLogRecord + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111161,19 +116918,19 @@ void uic_mqtt_dotdot_level_publish_generated_move_with_on_off_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_step_with_on_off_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_step_with_on_off_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_log_record_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/StepWithOnOff"; ++ topic += "DoorLock/GeneratedCommands/GetLogRecord"; + + std::string payload = +- get_json_payload_for_level_step_with_on_off_command( ++ get_json_payload_for_door_lock_get_log_record_command( + fields); + + // Publish our command +@@ -111183,11 +116940,11 @@ void uic_mqtt_dotdot_level_publish_generated_step_with_on_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated StopWithOnOff command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated GetLogRecordResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/StopWithOnOff ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetLogRecordResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111197,19 +116954,19 @@ void uic_mqtt_dotdot_level_publish_generated_step_with_on_off_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_stop_with_on_off_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_stop_with_on_off_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_log_record_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/StopWithOnOff"; ++ topic += "DoorLock/GeneratedCommands/GetLogRecordResponse"; + + std::string payload = +- get_json_payload_for_level_stop_with_on_off_command( ++ get_json_payload_for_door_lock_get_log_record_response_command( + fields); + + // Publish our command +@@ -111219,11 +116976,11 @@ void uic_mqtt_dotdot_level_publish_generated_stop_with_on_off_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToClosestFrequency command for +- * the Level cluster. ++ * @brief Publishes an incoming/generated SetPINCode command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Level/GeneratedCommands/MoveToClosestFrequency ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetPINCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111233,19 +116990,19 @@ void uic_mqtt_dotdot_level_publish_generated_stop_with_on_off_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_level_publish_generated_move_to_closest_frequency_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_level_command_move_to_closest_frequency_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_pin_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Level/GeneratedCommands/MoveToClosestFrequency"; ++ topic += "DoorLock/GeneratedCommands/SetPINCode"; + + std::string payload = +- get_json_payload_for_level_move_to_closest_frequency_command( ++ get_json_payload_for_door_lock_set_pin_code_command( + fields); + + // Publish our command +@@ -111255,11 +117012,11 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_closest_frequency_command( + false); + } + /** +- * @brief Publishes an incoming/generated ResetAlarm command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated SetPINCodeResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAlarm ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetPINCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111269,19 +117026,19 @@ void uic_mqtt_dotdot_level_publish_generated_move_to_closest_frequency_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_alarms_command_reset_alarm_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_pin_code_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/ResetAlarm"; ++ topic += "DoorLock/GeneratedCommands/SetPINCodeResponse"; + + std::string payload = +- get_json_payload_for_alarms_reset_alarm_command( ++ get_json_payload_for_door_lock_set_pin_code_response_command( + fields); + + // Publish our command +@@ -111291,11 +117048,11 @@ void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_command( + false); + } + /** +- * @brief Publishes an incoming/generated Alarm command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated GetPINCode command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/Alarm ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetPINCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111305,19 +117062,19 @@ void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_alarm_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_alarms_command_alarm_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_pin_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/Alarm"; ++ topic += "DoorLock/GeneratedCommands/GetPINCode"; + + std::string payload = +- get_json_payload_for_alarms_alarm_command( ++ get_json_payload_for_door_lock_get_pin_code_command( + fields); + + // Publish our command +@@ -111327,30 +117084,34 @@ void uic_mqtt_dotdot_alarms_publish_generated_alarm_command( + false); + } + /** +- * @brief Publishes an incoming/generated ResetAllAlarms command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated GetPINCodeResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAllAlarms ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetPINCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_reset_all_alarms_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_get_pin_code_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/ResetAllAlarms"; ++ topic += "DoorLock/GeneratedCommands/GetPINCodeResponse"; + + std::string payload = +- get_json_payload_for_alarms_reset_all_alarms_command( +- ); ++ get_json_payload_for_door_lock_get_pin_code_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -111359,11 +117120,11 @@ void uic_mqtt_dotdot_alarms_publish_generated_reset_all_alarms_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetAlarmResponse command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated ClearPINCode command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/GetAlarmResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearPINCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111373,19 +117134,19 @@ void uic_mqtt_dotdot_alarms_publish_generated_reset_all_alarms_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_alarms_command_get_alarm_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_pin_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/GetAlarmResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearPINCode"; + + std::string payload = +- get_json_payload_for_alarms_get_alarm_response_command( ++ get_json_payload_for_door_lock_clear_pin_code_command( + fields); + + // Publish our command +@@ -111395,30 +117156,34 @@ void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetAlarm command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated ClearPINCodeResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/GetAlarm ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearPINCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_clear_pin_code_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/GetAlarm"; ++ topic += "DoorLock/GeneratedCommands/ClearPINCodeResponse"; + + std::string payload = +- get_json_payload_for_alarms_get_alarm_command( +- ); ++ get_json_payload_for_door_lock_clear_pin_code_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -111427,11 +117192,11 @@ void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_command( + false); + } + /** +- * @brief Publishes an incoming/generated ResetAlarmLog command for +- * the Alarms cluster. ++ * @brief Publishes an incoming/generated ClearAllPINCodes command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Alarms/GeneratedCommands/ResetAlarmLog ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllPINCodes + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111439,17 +117204,17 @@ void uic_mqtt_dotdot_alarms_publish_generated_get_alarm_command( + * + * + */ +-void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_log_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Alarms/GeneratedCommands/ResetAlarmLog"; ++ topic += "DoorLock/GeneratedCommands/ClearAllPINCodes"; + + std::string payload = +- get_json_payload_for_alarms_reset_alarm_log_command( ++ get_json_payload_for_door_lock_clear_all_pin_codes_command( + ); + + // Publish our command +@@ -111459,30 +117224,34 @@ void uic_mqtt_dotdot_alarms_publish_generated_reset_alarm_log_command( + false); + } + /** +- * @brief Publishes an incoming/generated CheckIn command for +- * the PollControl cluster. ++ * @brief Publishes an incoming/generated ClearAllPINCodesResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/CheckIn ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllPINCodesResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_poll_control_publish_generated_check_in_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_clear_all_pin_codes_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "PollControl/GeneratedCommands/CheckIn"; ++ topic += "DoorLock/GeneratedCommands/ClearAllPINCodesResponse"; + + std::string payload = +- get_json_payload_for_poll_control_check_in_command( +- ); ++ get_json_payload_for_door_lock_clear_all_pin_codes_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -111491,11 +117260,11 @@ void uic_mqtt_dotdot_poll_control_publish_generated_check_in_command( + false); + } + /** +- * @brief Publishes an incoming/generated CheckInResponse command for +- * the PollControl cluster. ++ * @brief Publishes an incoming/generated SetUserStatus command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/CheckInResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserStatus + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111505,19 +117274,19 @@ void uic_mqtt_dotdot_poll_control_publish_generated_check_in_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_poll_control_publish_generated_check_in_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_poll_control_command_check_in_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_user_status_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "PollControl/GeneratedCommands/CheckInResponse"; ++ topic += "DoorLock/GeneratedCommands/SetUserStatus"; + + std::string payload = +- get_json_payload_for_poll_control_check_in_response_command( ++ get_json_payload_for_door_lock_set_user_status_command( + fields); + + // Publish our command +@@ -111527,30 +117296,34 @@ void uic_mqtt_dotdot_poll_control_publish_generated_check_in_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated FastPollStop command for +- * the PollControl cluster. ++ * @brief Publishes an incoming/generated SetUserStatusResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/FastPollStop ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserStatusResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_poll_control_publish_generated_fast_poll_stop_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_set_user_status_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "PollControl/GeneratedCommands/FastPollStop"; ++ topic += "DoorLock/GeneratedCommands/SetUserStatusResponse"; + + std::string payload = +- get_json_payload_for_poll_control_fast_poll_stop_command( +- ); ++ get_json_payload_for_door_lock_set_user_status_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -111559,11 +117332,11 @@ void uic_mqtt_dotdot_poll_control_publish_generated_fast_poll_stop_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetLongPollInterval command for +- * the PollControl cluster. ++ * @brief Publishes an incoming/generated GetUserStatus command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/SetLongPollInterval ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserStatus + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111573,19 +117346,19 @@ void uic_mqtt_dotdot_poll_control_publish_generated_fast_poll_stop_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_poll_control_publish_generated_set_long_poll_interval_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_poll_control_command_set_long_poll_interval_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_user_status_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "PollControl/GeneratedCommands/SetLongPollInterval"; ++ topic += "DoorLock/GeneratedCommands/GetUserStatus"; + + std::string payload = +- get_json_payload_for_poll_control_set_long_poll_interval_command( ++ get_json_payload_for_door_lock_get_user_status_command( + fields); + + // Publish our command +@@ -111595,11 +117368,11 @@ void uic_mqtt_dotdot_poll_control_publish_generated_set_long_poll_interval_comma + false); + } + /** +- * @brief Publishes an incoming/generated SetShortPollInterval command for +- * the PollControl cluster. ++ * @brief Publishes an incoming/generated GetUserStatusResponse command for ++ * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/PollControl/GeneratedCommands/SetShortPollInterval ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserStatusResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111609,19 +117382,19 @@ void uic_mqtt_dotdot_poll_control_publish_generated_set_long_poll_interval_comma + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_poll_control_publish_generated_set_short_poll_interval_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_poll_control_command_set_short_poll_interval_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_user_status_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "PollControl/GeneratedCommands/SetShortPollInterval"; ++ topic += "DoorLock/GeneratedCommands/GetUserStatusResponse"; + + std::string payload = +- get_json_payload_for_poll_control_set_short_poll_interval_command( ++ get_json_payload_for_door_lock_get_user_status_response_command( + fields); + + // Publish our command +@@ -111631,11 +117404,11 @@ void uic_mqtt_dotdot_poll_control_publish_generated_set_short_poll_interval_comm + false); + } + /** +- * @brief Publishes an incoming/generated LockDoor command for ++ * @brief Publishes an incoming/generated SetWeekdaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/LockDoor ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetWeekdaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111645,19 +117418,19 @@ void uic_mqtt_dotdot_poll_control_publish_generated_set_short_poll_interval_comm + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_lock_door_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/LockDoor"; ++ topic += "DoorLock/GeneratedCommands/SetWeekdaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_lock_door_command( ++ get_json_payload_for_door_lock_set_weekday_schedule_command( + fields); + + // Publish our command +@@ -111667,11 +117440,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_command( + false); + } + /** +- * @brief Publishes an incoming/generated LockDoorResponse command for ++ * @brief Publishes an incoming/generated SetWeekdayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/LockDoorResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetWeekdayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111681,19 +117454,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_lock_door_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/LockDoorResponse"; ++ topic += "DoorLock/GeneratedCommands/SetWeekdayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_lock_door_response_command( ++ get_json_payload_for_door_lock_set_weekday_schedule_response_command( + fields); + + // Publish our command +@@ -111703,11 +117476,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated UnlockDoor command for ++ * @brief Publishes an incoming/generated GetWeekdaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockDoor ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetWeekdaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111717,19 +117490,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_lock_door_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_unlock_door_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/UnlockDoor"; ++ topic += "DoorLock/GeneratedCommands/GetWeekdaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_unlock_door_command( ++ get_json_payload_for_door_lock_get_weekday_schedule_command( + fields); + + // Publish our command +@@ -111739,11 +117512,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_command( + false); + } + /** +- * @brief Publishes an incoming/generated UnlockDoorResponse command for ++ * @brief Publishes an incoming/generated GetWeekdayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockDoorResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetWeekdayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111753,19 +117526,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_unlock_door_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/UnlockDoorResponse"; ++ topic += "DoorLock/GeneratedCommands/GetWeekdayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_unlock_door_response_command( ++ get_json_payload_for_door_lock_get_weekday_schedule_response_command( + fields); + + // Publish our command +@@ -111775,11 +117548,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated Toggle command for ++ * @brief Publishes an incoming/generated ClearWeekdaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/Toggle ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearWeekdaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111789,19 +117562,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_door_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_toggle_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_toggle_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/Toggle"; ++ topic += "DoorLock/GeneratedCommands/ClearWeekdaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_toggle_command( ++ get_json_payload_for_door_lock_clear_weekday_schedule_command( + fields); + + // Publish our command +@@ -111811,11 +117584,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_toggle_command( + false); + } + /** +- * @brief Publishes an incoming/generated ToggleResponse command for ++ * @brief Publishes an incoming/generated ClearWeekdayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ToggleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearWeekdayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111825,19 +117598,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_toggle_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_toggle_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_toggle_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ToggleResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearWeekdayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_toggle_response_command( ++ get_json_payload_for_door_lock_clear_weekday_schedule_response_command( + fields); + + // Publish our command +@@ -111847,11 +117620,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_toggle_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated UnlockWithTimeout command for ++ * @brief Publishes an incoming/generated SetYearDaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockWithTimeout ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetYearDaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111861,19 +117634,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_toggle_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/UnlockWithTimeout"; ++ topic += "DoorLock/GeneratedCommands/SetYearDaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_unlock_with_timeout_command( ++ get_json_payload_for_door_lock_set_year_day_schedule_command( + fields); + + // Publish our command +@@ -111883,11 +117656,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_command( + false); + } + /** +- * @brief Publishes an incoming/generated UnlockWithTimeoutResponse command for ++ * @brief Publishes an incoming/generated SetYearDayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnlockWithTimeoutResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetYearDayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111897,19 +117670,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/UnlockWithTimeoutResponse"; ++ topic += "DoorLock/GeneratedCommands/SetYearDayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_unlock_with_timeout_response_command( ++ get_json_payload_for_door_lock_set_year_day_schedule_response_command( + fields); + + // Publish our command +@@ -111919,11 +117692,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_response_co + false); + } + /** +- * @brief Publishes an incoming/generated GetLogRecord command for ++ * @brief Publishes an incoming/generated GetYearDaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetLogRecord ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetYearDaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111933,19 +117706,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unlock_with_timeout_response_co + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_log_record_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetLogRecord"; ++ topic += "DoorLock/GeneratedCommands/GetYearDaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_get_log_record_command( ++ get_json_payload_for_door_lock_get_year_day_schedule_command( + fields); + + // Publish our command +@@ -111955,11 +117728,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetLogRecordResponse command for ++ * @brief Publishes an incoming/generated GetYearDayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetLogRecordResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetYearDayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -111969,19 +117742,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_log_record_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetLogRecordResponse"; ++ topic += "DoorLock/GeneratedCommands/GetYearDayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_log_record_response_command( ++ get_json_payload_for_door_lock_get_year_day_schedule_response_command( + fields); + + // Publish our command +@@ -111991,11 +117764,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_response_command + false); + } + /** +- * @brief Publishes an incoming/generated SetPINCode command for ++ * @brief Publishes an incoming/generated ClearYearDaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetPINCode ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearYearDaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112005,19 +117778,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_log_record_response_command + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_pin_code_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetPINCode"; ++ topic += "DoorLock/GeneratedCommands/ClearYearDaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_set_pin_code_command( ++ get_json_payload_for_door_lock_clear_year_day_schedule_command( + fields); + + // Publish our command +@@ -112027,11 +117800,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetPINCodeResponse command for ++ * @brief Publishes an incoming/generated ClearYearDayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetPINCodeResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearYearDayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112041,19 +117814,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_pin_code_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetPINCodeResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearYearDayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_set_pin_code_response_command( ++ get_json_payload_for_door_lock_clear_year_day_schedule_response_command( + fields); + + // Publish our command +@@ -112063,11 +117836,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetPINCode command for ++ * @brief Publishes an incoming/generated SetHolidaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetPINCode ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetHolidaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112077,19 +117850,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_pin_code_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_pin_code_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetPINCode"; ++ topic += "DoorLock/GeneratedCommands/SetHolidaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_get_pin_code_command( ++ get_json_payload_for_door_lock_set_holiday_schedule_command( + fields); + + // Publish our command +@@ -112099,11 +117872,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetPINCodeResponse command for ++ * @brief Publishes an incoming/generated SetHolidayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetPINCodeResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetHolidayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112113,19 +117886,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_pin_code_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetPINCodeResponse"; ++ topic += "DoorLock/GeneratedCommands/SetHolidayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_pin_code_response_command( ++ get_json_payload_for_door_lock_set_holiday_schedule_response_command( + fields); + + // Publish our command +@@ -112135,11 +117908,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearPINCode command for ++ * @brief Publishes an incoming/generated GetHolidaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearPINCode ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetHolidaySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112149,19 +117922,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_pin_code_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_pin_code_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearPINCode"; ++ topic += "DoorLock/GeneratedCommands/GetHolidaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_clear_pin_code_command( ++ get_json_payload_for_door_lock_get_holiday_schedule_command( + fields); + + // Publish our command +@@ -112171,11 +117944,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearPINCodeResponse command for ++ * @brief Publishes an incoming/generated GetHolidayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearPINCodeResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetHolidayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112185,19 +117958,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_pin_code_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearPINCodeResponse"; ++ topic += "DoorLock/GeneratedCommands/GetHolidayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_clear_pin_code_response_command( ++ get_json_payload_for_door_lock_get_holiday_schedule_response_command( + fields); + + // Publish our command +@@ -112207,30 +117980,34 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_pin_code_response_command + false); + } + /** +- * @brief Publishes an incoming/generated ClearAllPINCodes command for ++ * @brief Publishes an incoming/generated ClearHolidaySchedule command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllPINCodes ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearHolidaySchedule + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearAllPINCodes"; ++ topic += "DoorLock/GeneratedCommands/ClearHolidaySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_clear_all_pin_codes_command( +- ); ++ get_json_payload_for_door_lock_clear_holiday_schedule_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -112239,11 +118016,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearAllPINCodesResponse command for ++ * @brief Publishes an incoming/generated ClearHolidayScheduleResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllPINCodesResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearHolidayScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112253,19 +118030,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_all_pin_codes_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearAllPINCodesResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearHolidayScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_clear_all_pin_codes_response_command( ++ get_json_payload_for_door_lock_clear_holiday_schedule_response_command( + fields); + + // Publish our command +@@ -112275,11 +118052,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_response_co + false); + } + /** +- * @brief Publishes an incoming/generated SetUserStatus command for ++ * @brief Publishes an incoming/generated SetUserType command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserStatus ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserType + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112289,19 +118066,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_pin_codes_response_co + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_user_status_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_user_type_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetUserStatus"; ++ topic += "DoorLock/GeneratedCommands/SetUserType"; + + std::string payload = +- get_json_payload_for_door_lock_set_user_status_command( ++ get_json_payload_for_door_lock_set_user_type_command( + fields); + + // Publish our command +@@ -112311,11 +118088,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetUserStatusResponse command for ++ * @brief Publishes an incoming/generated SetUserTypeResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserStatusResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserTypeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112325,19 +118102,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_user_status_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_user_type_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetUserStatusResponse"; ++ topic += "DoorLock/GeneratedCommands/SetUserTypeResponse"; + + std::string payload = +- get_json_payload_for_door_lock_set_user_status_response_command( ++ get_json_payload_for_door_lock_set_user_type_response_command( + fields); + + // Publish our command +@@ -112347,11 +118124,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_response_comman + false); + } + /** +- * @brief Publishes an incoming/generated GetUserStatus command for ++ * @brief Publishes an incoming/generated GetUserType command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserStatus ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserType + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112361,19 +118138,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_status_response_comman + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_user_status_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_user_type_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUserStatus"; ++ topic += "DoorLock/GeneratedCommands/GetUserType"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_status_command( ++ get_json_payload_for_door_lock_get_user_type_command( + fields); + + // Publish our command +@@ -112383,11 +118160,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetUserStatusResponse command for ++ * @brief Publishes an incoming/generated GetUserTypeResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserStatusResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserTypeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112397,19 +118174,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_user_status_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_user_type_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUserStatusResponse"; ++ topic += "DoorLock/GeneratedCommands/GetUserTypeResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_status_response_command( ++ get_json_payload_for_door_lock_get_user_type_response_command( + fields); + + // Publish our command +@@ -112419,11 +118196,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_response_comman + false); + } + /** +- * @brief Publishes an incoming/generated SetWeekdaySchedule command for ++ * @brief Publishes an incoming/generated SetRFIDCode command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetWeekdaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetRFIDCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112433,19 +118210,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_status_response_comman + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_rfid_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetWeekdaySchedule"; ++ topic += "DoorLock/GeneratedCommands/SetRFIDCode"; + + std::string payload = +- get_json_payload_for_door_lock_set_weekday_schedule_command( ++ get_json_payload_for_door_lock_set_rfid_code_command( + fields); + + // Publish our command +@@ -112455,11 +118232,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetWeekdayScheduleResponse command for ++ * @brief Publishes an incoming/generated SetRFIDCodeResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetWeekdayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetRFIDCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112469,19 +118246,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_rfid_code_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetWeekdayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/SetRFIDCodeResponse"; + + std::string payload = +- get_json_payload_for_door_lock_set_weekday_schedule_response_command( ++ get_json_payload_for_door_lock_set_rfid_code_response_command( + fields); + + // Publish our command +@@ -112491,11 +118268,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_response_c + false); + } + /** +- * @brief Publishes an incoming/generated GetWeekdaySchedule command for ++ * @brief Publishes an incoming/generated GetRFIDCode command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetWeekdaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetRFIDCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112505,19 +118282,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_weekday_schedule_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_rfid_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetWeekdaySchedule"; ++ topic += "DoorLock/GeneratedCommands/GetRFIDCode"; + + std::string payload = +- get_json_payload_for_door_lock_get_weekday_schedule_command( ++ get_json_payload_for_door_lock_get_rfid_code_command( + fields); + + // Publish our command +@@ -112527,11 +118304,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetWeekdayScheduleResponse command for ++ * @brief Publishes an incoming/generated GetRFIDCodeResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetWeekdayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetRFIDCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112541,19 +118318,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_rfid_code_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetWeekdayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/GetRFIDCodeResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_weekday_schedule_response_command( ++ get_json_payload_for_door_lock_get_rfid_code_response_command( + fields); + + // Publish our command +@@ -112563,11 +118340,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_response_c + false); + } + /** +- * @brief Publishes an incoming/generated ClearWeekdaySchedule command for ++ * @brief Publishes an incoming/generated ClearRFIDCode command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearWeekdaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearRFIDCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112577,19 +118354,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_weekday_schedule_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_rfid_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearWeekdaySchedule"; ++ topic += "DoorLock/GeneratedCommands/ClearRFIDCode"; + + std::string payload = +- get_json_payload_for_door_lock_clear_weekday_schedule_command( ++ get_json_payload_for_door_lock_clear_rfid_code_command( + fields); + + // Publish our command +@@ -112599,11 +118376,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearWeekdayScheduleResponse command for ++ * @brief Publishes an incoming/generated ClearRFIDCodeResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearWeekdayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearRFIDCodeResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112613,19 +118390,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_rfid_code_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearWeekdayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearRFIDCodeResponse"; + + std::string payload = +- get_json_payload_for_door_lock_clear_weekday_schedule_response_command( ++ get_json_payload_for_door_lock_clear_rfid_code_response_command( + fields); + + // Publish our command +@@ -112635,34 +118412,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_weekday_schedule_response + false); + } + /** +- * @brief Publishes an incoming/generated SetYearDaySchedule command for ++ * @brief Publishes an incoming/generated ClearAllRFIDCodes command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetYearDaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllRFIDCodes + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetYearDaySchedule"; ++ topic += "DoorLock/GeneratedCommands/ClearAllRFIDCodes"; + + std::string payload = +- get_json_payload_for_door_lock_set_year_day_schedule_command( +- fields); ++ get_json_payload_for_door_lock_clear_all_rfid_codes_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -112671,11 +118444,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetYearDayScheduleResponse command for ++ * @brief Publishes an incoming/generated ClearAllRFIDCodesResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetYearDayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllRFIDCodesResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112685,19 +118458,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_all_rfid_codes_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetYearDayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearAllRFIDCodesResponse"; + + std::string payload = +- get_json_payload_for_door_lock_set_year_day_schedule_response_command( ++ get_json_payload_for_door_lock_clear_all_rfid_codes_response_command( + fields); + + // Publish our command +@@ -112707,11 +118480,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_response_ + false); + } + /** +- * @brief Publishes an incoming/generated GetYearDaySchedule command for ++ * @brief Publishes an incoming/generated SetUser command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetYearDaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112721,19 +118494,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_year_day_schedule_response_ + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetYearDaySchedule"; ++ topic += "DoorLock/GeneratedCommands/SetUser"; + + std::string payload = +- get_json_payload_for_door_lock_get_year_day_schedule_command( ++ get_json_payload_for_door_lock_set_user_command( + fields); + + // Publish our command +@@ -112743,11 +118516,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetYearDayScheduleResponse command for ++ * @brief Publishes an incoming/generated GetUser command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetYearDayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112757,19 +118530,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetYearDayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/GetUser"; + + std::string payload = +- get_json_payload_for_door_lock_get_year_day_schedule_response_command( ++ get_json_payload_for_door_lock_get_user_command( + fields); + + // Publish our command +@@ -112779,34 +118552,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_year_day_schedule_response_ + false); + } + /** +- * @brief Publishes an incoming/generated ClearYearDaySchedule command for ++ * @brief Publishes an incoming/generated GetUserResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearYearDaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_user_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearYearDaySchedule"; ++ topic += "DoorLock/GeneratedCommands/GetUserResponse"; + + std::string payload = +- get_json_payload_for_door_lock_clear_year_day_schedule_command( +- fields); ++ get_json_payload_for_door_lock_get_user_response_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -112815,11 +118584,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_command + false); + } + /** +- * @brief Publishes an incoming/generated ClearYearDayScheduleResponse command for ++ * @brief Publishes an incoming/generated ClearUser command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearYearDayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112829,19 +118598,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_command + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearYearDayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/ClearUser"; + + std::string payload = +- get_json_payload_for_door_lock_clear_year_day_schedule_response_command( ++ get_json_payload_for_door_lock_clear_user_command( + fields); + + // Publish our command +@@ -112851,11 +118620,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_respons + false); + } + /** +- * @brief Publishes an incoming/generated SetHolidaySchedule command for ++ * @brief Publishes an incoming/generated OperatingEventNotification command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetHolidaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/OperatingEventNotification + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112865,19 +118634,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_year_day_schedule_respons + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_operating_event_notification_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_operating_event_notification_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetHolidaySchedule"; ++ topic += "DoorLock/GeneratedCommands/OperatingEventNotification"; + + std::string payload = +- get_json_payload_for_door_lock_set_holiday_schedule_command( ++ get_json_payload_for_door_lock_operating_event_notification_command( + fields); + + // Publish our command +@@ -112887,11 +118656,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetHolidayScheduleResponse command for ++ * @brief Publishes an incoming/generated ProgrammingEventNotification command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetHolidayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ProgrammingEventNotification + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112901,19 +118670,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_programming_event_notification_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_programming_event_notification_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetHolidayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/ProgrammingEventNotification"; + + std::string payload = +- get_json_payload_for_door_lock_set_holiday_schedule_response_command( ++ get_json_payload_for_door_lock_programming_event_notification_command( + fields); + + // Publish our command +@@ -112923,11 +118692,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_response_c + false); + } + /** +- * @brief Publishes an incoming/generated GetHolidaySchedule command for ++ * @brief Publishes an incoming/generated SetCredential command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetHolidaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetCredential + * + * @param unid The UNID of the node that sent us the command. + * +@@ -112937,19 +118706,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_holiday_schedule_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_set_credential_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetHolidaySchedule"; ++ topic += "DoorLock/GeneratedCommands/SetCredential"; + + std::string payload = +- get_json_payload_for_door_lock_get_holiday_schedule_command( ++ get_json_payload_for_door_lock_set_credential_command( + fields); + + // Publish our command +@@ -112959,34 +118728,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetHolidayScheduleResponse command for ++ * @brief Publishes an incoming/generated SetCredentialResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetHolidayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetCredentialResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetHolidayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/SetCredentialResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_holiday_schedule_response_command( +- fields); ++ get_json_payload_for_door_lock_set_credential_response_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -112995,11 +118760,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_response_c + false); + } + /** +- * @brief Publishes an incoming/generated ClearHolidaySchedule command for ++ * @brief Publishes an incoming/generated GetCredentialStatus command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearHolidaySchedule ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetCredentialStatus + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113009,19 +118774,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_holiday_schedule_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_get_credential_status_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearHolidaySchedule"; ++ topic += "DoorLock/GeneratedCommands/GetCredentialStatus"; + + std::string payload = +- get_json_payload_for_door_lock_clear_holiday_schedule_command( ++ get_json_payload_for_door_lock_get_credential_status_command( + fields); + + // Publish our command +@@ -113031,34 +118796,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearHolidayScheduleResponse command for ++ * @brief Publishes an incoming/generated GetCredentialStatusResponse command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearHolidayScheduleResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetCredentialStatusResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearHolidayScheduleResponse"; ++ topic += "DoorLock/GeneratedCommands/GetCredentialStatusResponse"; + + std::string payload = +- get_json_payload_for_door_lock_clear_holiday_schedule_response_command( +- fields); ++ get_json_payload_for_door_lock_get_credential_status_response_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113067,11 +118828,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_response + false); + } + /** +- * @brief Publishes an incoming/generated SetUserType command for ++ * @brief Publishes an incoming/generated ClearCredential command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserType ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearCredential + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113081,19 +118842,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_holiday_schedule_response + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_clear_credential_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_user_type_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_clear_credential_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetUserType"; ++ topic += "DoorLock/GeneratedCommands/ClearCredential"; + + std::string payload = +- get_json_payload_for_door_lock_set_user_type_command( ++ get_json_payload_for_door_lock_clear_credential_command( + fields); + + // Publish our command +@@ -113103,11 +118864,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetUserTypeResponse command for ++ * @brief Publishes an incoming/generated UnboltDoor command for + * the DoorLock cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUserTypeResponse ++ * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnboltDoor + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113117,19 +118878,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_response_command( ++void uic_mqtt_dotdot_door_lock_publish_generated_unbolt_door_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_user_type_response_fields_t *fields ++ const uic_mqtt_dotdot_door_lock_command_unbolt_door_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetUserTypeResponse"; ++ topic += "DoorLock/GeneratedCommands/UnboltDoor"; + + std::string payload = +- get_json_payload_for_door_lock_set_user_type_response_command( ++ get_json_payload_for_door_lock_unbolt_door_command( + fields); + + // Publish our command +@@ -113139,34 +118900,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_type_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetUserType command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated UpOrOpen command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserType ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/UpOrOpen + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_up_or_open_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_user_type_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUserType"; ++ topic += "WindowCovering/GeneratedCommands/UpOrOpen"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_type_command( +- fields); ++ get_json_payload_for_window_covering_up_or_open_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113175,34 +118932,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetUserTypeResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated DownOrClose command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserTypeResponse ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/DownOrClose + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_response_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_down_or_close_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_user_type_response_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUserTypeResponse"; ++ topic += "WindowCovering/GeneratedCommands/DownOrClose"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_type_response_command( +- fields); ++ get_json_payload_for_window_covering_down_or_close_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113211,34 +118964,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_type_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetRFIDCode command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated Stop command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetRFIDCode ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/Stop + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_stop_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_rfid_code_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetRFIDCode"; ++ topic += "WindowCovering/GeneratedCommands/Stop"; + + std::string payload = +- get_json_payload_for_door_lock_set_rfid_code_command( +- fields); ++ get_json_payload_for_window_covering_stop_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113247,11 +118996,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetRFIDCodeResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GoToLiftValue command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetRFIDCodeResponse ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToLiftValue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113261,19 +119010,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_response_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_value_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_rfid_code_response_fields_t *fields ++ const uic_mqtt_dotdot_window_covering_command_go_to_lift_value_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetRFIDCodeResponse"; ++ topic += "WindowCovering/GeneratedCommands/GoToLiftValue"; + + std::string payload = +- get_json_payload_for_door_lock_set_rfid_code_response_command( ++ get_json_payload_for_window_covering_go_to_lift_value_command( + fields); + + // Publish our command +@@ -113283,11 +119032,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetRFIDCode command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GoToLiftPercentage command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetRFIDCode ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToLiftPercentage + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113297,19 +119046,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_rfid_code_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_percentage_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_rfid_code_fields_t *fields ++ const uic_mqtt_dotdot_window_covering_command_go_to_lift_percentage_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetRFIDCode"; ++ topic += "WindowCovering/GeneratedCommands/GoToLiftPercentage"; + + std::string payload = +- get_json_payload_for_door_lock_get_rfid_code_command( ++ get_json_payload_for_window_covering_go_to_lift_percentage_command( + fields); + + // Publish our command +@@ -113319,11 +119068,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetRFIDCodeResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GoToTiltValue command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetRFIDCodeResponse ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToTiltValue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113333,19 +119082,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_response_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_value_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_rfid_code_response_fields_t *fields ++ const uic_mqtt_dotdot_window_covering_command_go_to_tilt_value_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetRFIDCodeResponse"; ++ topic += "WindowCovering/GeneratedCommands/GoToTiltValue"; + + std::string payload = +- get_json_payload_for_door_lock_get_rfid_code_response_command( ++ get_json_payload_for_window_covering_go_to_tilt_value_command( + fields); + + // Publish our command +@@ -113355,11 +119104,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearRFIDCode command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GoToTiltPercentage command for ++ * the WindowCovering cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearRFIDCode ++ * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToTiltPercentage + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113369,19 +119118,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_rfid_code_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_command( ++void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_percentage_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_rfid_code_fields_t *fields ++ const uic_mqtt_dotdot_window_covering_command_go_to_tilt_percentage_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearRFIDCode"; ++ topic += "WindowCovering/GeneratedCommands/GoToTiltPercentage"; + + std::string payload = +- get_json_payload_for_door_lock_clear_rfid_code_command( ++ get_json_payload_for_window_covering_go_to_tilt_percentage_command( + fields); + + // Publish our command +@@ -113391,11 +119140,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearRFIDCodeResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GoToPercent command for ++ * the BarrierControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearRFIDCodeResponse ++ * ucl/by-unid/UNID/epID/BarrierControl/GeneratedCommands/GoToPercent + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113405,19 +119154,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_response_command( ++void uic_mqtt_dotdot_barrier_control_publish_generated_go_to_percent_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_rfid_code_response_fields_t *fields ++ const uic_mqtt_dotdot_barrier_control_command_go_to_percent_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearRFIDCodeResponse"; ++ topic += "BarrierControl/GeneratedCommands/GoToPercent"; + + std::string payload = +- get_json_payload_for_door_lock_clear_rfid_code_response_command( ++ get_json_payload_for_barrier_control_go_to_percent_command( + fields); + + // Publish our command +@@ -113427,11 +119176,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_response_comman + false); + } + /** +- * @brief Publishes an incoming/generated ClearAllRFIDCodes command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated Stop command for ++ * the BarrierControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllRFIDCodes ++ * ucl/by-unid/UNID/epID/BarrierControl/GeneratedCommands/Stop + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113439,17 +119188,17 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_rfid_code_response_comman + * + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_command( ++void uic_mqtt_dotdot_barrier_control_publish_generated_stop_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearAllRFIDCodes"; ++ topic += "BarrierControl/GeneratedCommands/Stop"; + + std::string payload = +- get_json_payload_for_door_lock_clear_all_rfid_codes_command( ++ get_json_payload_for_barrier_control_stop_command( + ); + + // Publish our command +@@ -113459,11 +119208,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearAllRFIDCodesResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated SetpointRaiseOrLower command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearAllRFIDCodesResponse ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/SetpointRaiseOrLower + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113473,19 +119222,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_response_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_setpoint_raise_or_lower_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_all_rfid_codes_response_fields_t *fields ++ const uic_mqtt_dotdot_thermostat_command_setpoint_raise_or_lower_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearAllRFIDCodesResponse"; ++ topic += "Thermostat/GeneratedCommands/SetpointRaiseOrLower"; + + std::string payload = +- get_json_payload_for_door_lock_clear_all_rfid_codes_response_command( ++ get_json_payload_for_thermostat_setpoint_raise_or_lower_command( + fields); + + // Publish our command +@@ -113495,11 +119244,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_response_c + false); + } + /** +- * @brief Publishes an incoming/generated SetUser command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GetWeeklyScheduleResponse command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetUser ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetWeeklyScheduleResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113509,19 +119258,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_all_rfid_codes_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_user_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_user_fields_t *fields ++ const uic_mqtt_dotdot_thermostat_command_get_weekly_schedule_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetUser"; ++ topic += "Thermostat/GeneratedCommands/GetWeeklyScheduleResponse"; + + std::string payload = +- get_json_payload_for_door_lock_set_user_command( ++ get_json_payload_for_thermostat_get_weekly_schedule_response_command( + fields); + + // Publish our command +@@ -113531,11 +119280,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetUser command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated SetWeeklySchedule command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUser ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/SetWeeklySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113545,19 +119294,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_user_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_set_weekly_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_user_fields_t *fields ++ const uic_mqtt_dotdot_thermostat_command_set_weekly_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUser"; ++ topic += "Thermostat/GeneratedCommands/SetWeeklySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_command( ++ get_json_payload_for_thermostat_set_weekly_schedule_command( + fields); + + // Publish our command +@@ -113567,30 +119316,34 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetUserResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GetRelayStatusLogResponse command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetUserResponse ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetRelayStatusLogResponse + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_user_response_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_response_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_thermostat_command_get_relay_status_log_response_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetUserResponse"; ++ topic += "Thermostat/GeneratedCommands/GetRelayStatusLogResponse"; + + std::string payload = +- get_json_payload_for_door_lock_get_user_response_command( +- ); ++ get_json_payload_for_thermostat_get_relay_status_log_response_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113599,11 +119352,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearUser command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GetWeeklySchedule command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearUser ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetWeeklySchedule + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113613,19 +119366,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_user_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_user_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_user_fields_t *fields ++ const uic_mqtt_dotdot_thermostat_command_get_weekly_schedule_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearUser"; ++ topic += "Thermostat/GeneratedCommands/GetWeeklySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_clear_user_command( ++ get_json_payload_for_thermostat_get_weekly_schedule_command( + fields); + + // Publish our command +@@ -113635,34 +119388,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_user_command( + false); + } + /** +- * @brief Publishes an incoming/generated OperatingEventNotification command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated ClearWeeklySchedule command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/OperatingEventNotification ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/ClearWeeklySchedule + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_operating_event_notification_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_clear_weekly_schedule_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_operating_event_notification_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/OperatingEventNotification"; ++ topic += "Thermostat/GeneratedCommands/ClearWeeklySchedule"; + + std::string payload = +- get_json_payload_for_door_lock_operating_event_notification_command( +- fields); ++ get_json_payload_for_thermostat_clear_weekly_schedule_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113671,34 +119420,30 @@ void uic_mqtt_dotdot_door_lock_publish_generated_operating_event_notification_co + false); + } + /** +- * @brief Publishes an incoming/generated ProgrammingEventNotification command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated GetRelayStatusLog command for ++ * the Thermostat cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ProgrammingEventNotification ++ * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetRelayStatusLog + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_programming_event_notification_command( ++void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_programming_event_notification_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ProgrammingEventNotification"; ++ topic += "Thermostat/GeneratedCommands/GetRelayStatusLog"; + + std::string payload = +- get_json_payload_for_door_lock_programming_event_notification_command( +- fields); ++ get_json_payload_for_thermostat_get_relay_status_log_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113707,11 +119452,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_programming_event_notification_ + false); + } + /** +- * @brief Publishes an incoming/generated SetCredential command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated MoveToHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetCredential ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToHue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113721,19 +119466,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_programming_event_notification_ + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_set_credential_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_move_to_hue_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetCredential"; ++ topic += "ColorControl/GeneratedCommands/MoveToHue"; + + std::string payload = +- get_json_payload_for_door_lock_set_credential_command( ++ get_json_payload_for_color_control_move_to_hue_command( + fields); + + // Publish our command +@@ -113743,30 +119488,34 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetCredentialResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated MoveHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/SetCredentialResponse ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveHue + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_response_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_hue_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_move_hue_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/SetCredentialResponse"; ++ topic += "ColorControl/GeneratedCommands/MoveHue"; + + std::string payload = +- get_json_payload_for_door_lock_set_credential_response_command( +- ); ++ get_json_payload_for_color_control_move_hue_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113775,11 +119524,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_response_command + false); + } + /** +- * @brief Publishes an incoming/generated GetCredentialStatus command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated StepHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetCredentialStatus ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepHue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113789,19 +119538,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_set_credential_response_command + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_command( ++void uic_mqtt_dotdot_color_control_publish_generated_step_hue_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_get_credential_status_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_step_hue_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetCredentialStatus"; ++ topic += "ColorControl/GeneratedCommands/StepHue"; + + std::string payload = +- get_json_payload_for_door_lock_get_credential_status_command( ++ get_json_payload_for_color_control_step_hue_command( + fields); + + // Publish our command +@@ -113811,30 +119560,34 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetCredentialStatusResponse command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated MoveToSaturation command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/GetCredentialStatusResponse ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToSaturation + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_response_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_to_saturation_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_move_to_saturation_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/GetCredentialStatusResponse"; ++ topic += "ColorControl/GeneratedCommands/MoveToSaturation"; + + std::string payload = +- get_json_payload_for_door_lock_get_credential_status_response_command( +- ); ++ get_json_payload_for_color_control_move_to_saturation_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113843,11 +119596,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_response_ + false); + } + /** +- * @brief Publishes an incoming/generated ClearCredential command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated MoveSaturation command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/ClearCredential ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveSaturation + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113857,19 +119610,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_get_credential_status_response_ + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_clear_credential_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_saturation_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_clear_credential_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_move_saturation_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/ClearCredential"; ++ topic += "ColorControl/GeneratedCommands/MoveSaturation"; + + std::string payload = +- get_json_payload_for_door_lock_clear_credential_command( ++ get_json_payload_for_color_control_move_saturation_command( + fields); + + // Publish our command +@@ -113879,11 +119632,11 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_credential_command( + false); + } + /** +- * @brief Publishes an incoming/generated UnboltDoor command for +- * the DoorLock cluster. ++ * @brief Publishes an incoming/generated StepSaturation command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/DoorLock/GeneratedCommands/UnboltDoor ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepSaturation + * + * @param unid The UNID of the node that sent us the command. + * +@@ -113893,19 +119646,19 @@ void uic_mqtt_dotdot_door_lock_publish_generated_clear_credential_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_door_lock_publish_generated_unbolt_door_command( ++void uic_mqtt_dotdot_color_control_publish_generated_step_saturation_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_door_lock_command_unbolt_door_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_step_saturation_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "DoorLock/GeneratedCommands/UnboltDoor"; ++ topic += "ColorControl/GeneratedCommands/StepSaturation"; + + std::string payload = +- get_json_payload_for_door_lock_unbolt_door_command( ++ get_json_payload_for_color_control_step_saturation_command( + fields); + + // Publish our command +@@ -113915,30 +119668,34 @@ void uic_mqtt_dotdot_door_lock_publish_generated_unbolt_door_command( + false); + } + /** +- * @brief Publishes an incoming/generated UpOrOpen command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated MoveToHueAndSaturation command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/UpOrOpen ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToHueAndSaturation + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_up_or_open_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_and_saturation_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_move_to_hue_and_saturation_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/UpOrOpen"; ++ topic += "ColorControl/GeneratedCommands/MoveToHueAndSaturation"; + + std::string payload = +- get_json_payload_for_window_covering_up_or_open_command( +- ); ++ get_json_payload_for_color_control_move_to_hue_and_saturation_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113947,30 +119704,34 @@ void uic_mqtt_dotdot_window_covering_publish_generated_up_or_open_command( + false); + } + /** +- * @brief Publishes an incoming/generated DownOrClose command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated MoveToColor command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/DownOrClose ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToColor + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_down_or_close_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_move_to_color_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/DownOrClose"; ++ topic += "ColorControl/GeneratedCommands/MoveToColor"; + + std::string payload = +- get_json_payload_for_window_covering_down_or_close_command( +- ); ++ get_json_payload_for_color_control_move_to_color_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -113979,30 +119740,34 @@ void uic_mqtt_dotdot_window_covering_publish_generated_down_or_close_command( + false); + } + /** +- * @brief Publishes an incoming/generated Stop command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated MoveColor command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/Stop ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveColor + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_stop_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_color_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_move_color_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/Stop"; ++ topic += "ColorControl/GeneratedCommands/MoveColor"; + + std::string payload = +- get_json_payload_for_window_covering_stop_command( +- ); ++ get_json_payload_for_color_control_move_color_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114011,11 +119776,11 @@ void uic_mqtt_dotdot_window_covering_publish_generated_stop_command( + false); + } + /** +- * @brief Publishes an incoming/generated GoToLiftValue command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated StepColor command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToLiftValue ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepColor + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114025,19 +119790,19 @@ void uic_mqtt_dotdot_window_covering_publish_generated_stop_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_value_command( ++void uic_mqtt_dotdot_color_control_publish_generated_step_color_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_window_covering_command_go_to_lift_value_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_step_color_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/GoToLiftValue"; ++ topic += "ColorControl/GeneratedCommands/StepColor"; + + std::string payload = +- get_json_payload_for_window_covering_go_to_lift_value_command( ++ get_json_payload_for_color_control_step_color_command( + fields); + + // Publish our command +@@ -114047,11 +119812,11 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_value_command( + false); + } + /** +- * @brief Publishes an incoming/generated GoToLiftPercentage command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated MoveToColorTemperature command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToLiftPercentage ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToColorTemperature + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114061,19 +119826,19 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_value_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_percentage_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_temperature_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_window_covering_command_go_to_lift_percentage_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_move_to_color_temperature_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/GoToLiftPercentage"; ++ topic += "ColorControl/GeneratedCommands/MoveToColorTemperature"; + + std::string payload = +- get_json_payload_for_window_covering_go_to_lift_percentage_command( ++ get_json_payload_for_color_control_move_to_color_temperature_command( + fields); + + // Publish our command +@@ -114083,11 +119848,11 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_percentage_com + false); + } + /** +- * @brief Publishes an incoming/generated GoToTiltValue command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated EnhancedMoveToHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToTiltValue ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveToHue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114097,19 +119862,19 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_lift_percentage_com + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_value_command( ++void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_window_covering_command_go_to_tilt_value_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_enhanced_move_to_hue_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/GoToTiltValue"; ++ topic += "ColorControl/GeneratedCommands/EnhancedMoveToHue"; + + std::string payload = +- get_json_payload_for_window_covering_go_to_tilt_value_command( ++ get_json_payload_for_color_control_enhanced_move_to_hue_command( + fields); + + // Publish our command +@@ -114119,11 +119884,11 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_value_command( + false); + } + /** +- * @brief Publishes an incoming/generated GoToTiltPercentage command for +- * the WindowCovering cluster. ++ * @brief Publishes an incoming/generated EnhancedMoveHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/WindowCovering/GeneratedCommands/GoToTiltPercentage ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveHue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114133,19 +119898,19 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_value_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_percentage_command( ++void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_hue_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_window_covering_command_go_to_tilt_percentage_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_enhanced_move_hue_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "WindowCovering/GeneratedCommands/GoToTiltPercentage"; ++ topic += "ColorControl/GeneratedCommands/EnhancedMoveHue"; + + std::string payload = +- get_json_payload_for_window_covering_go_to_tilt_percentage_command( ++ get_json_payload_for_color_control_enhanced_move_hue_command( + fields); + + // Publish our command +@@ -114155,11 +119920,11 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_percentage_com + false); + } + /** +- * @brief Publishes an incoming/generated GoToPercent command for +- * the BarrierControl cluster. ++ * @brief Publishes an incoming/generated EnhancedStepHue command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/BarrierControl/GeneratedCommands/GoToPercent ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedStepHue + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114169,19 +119934,19 @@ void uic_mqtt_dotdot_window_covering_publish_generated_go_to_tilt_percentage_com + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_barrier_control_publish_generated_go_to_percent_command( ++void uic_mqtt_dotdot_color_control_publish_generated_enhanced_step_hue_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_barrier_control_command_go_to_percent_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_enhanced_step_hue_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "BarrierControl/GeneratedCommands/GoToPercent"; ++ topic += "ColorControl/GeneratedCommands/EnhancedStepHue"; + + std::string payload = +- get_json_payload_for_barrier_control_go_to_percent_command( ++ get_json_payload_for_color_control_enhanced_step_hue_command( + fields); + + // Publish our command +@@ -114191,30 +119956,34 @@ void uic_mqtt_dotdot_barrier_control_publish_generated_go_to_percent_command( + false); + } + /** +- * @brief Publishes an incoming/generated Stop command for +- * the BarrierControl cluster. ++ * @brief Publishes an incoming/generated EnhancedMoveToHueAndSaturation command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/BarrierControl/GeneratedCommands/Stop ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveToHueAndSaturation + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_barrier_control_publish_generated_stop_command( ++void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_and_saturation_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_color_control_command_enhanced_move_to_hue_and_saturation_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "BarrierControl/GeneratedCommands/Stop"; ++ topic += "ColorControl/GeneratedCommands/EnhancedMoveToHueAndSaturation"; + + std::string payload = +- get_json_payload_for_barrier_control_stop_command( +- ); ++ get_json_payload_for_color_control_enhanced_move_to_hue_and_saturation_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114223,11 +119992,11 @@ void uic_mqtt_dotdot_barrier_control_publish_generated_stop_command( + false); + } + /** +- * @brief Publishes an incoming/generated SetpointRaiseOrLower command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated ColorLoopSet command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/SetpointRaiseOrLower ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/ColorLoopSet + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114237,19 +120006,19 @@ void uic_mqtt_dotdot_barrier_control_publish_generated_stop_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_setpoint_raise_or_lower_command( ++void uic_mqtt_dotdot_color_control_publish_generated_color_loop_set_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_thermostat_command_setpoint_raise_or_lower_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_color_loop_set_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/SetpointRaiseOrLower"; ++ topic += "ColorControl/GeneratedCommands/ColorLoopSet"; + + std::string payload = +- get_json_payload_for_thermostat_setpoint_raise_or_lower_command( ++ get_json_payload_for_color_control_color_loop_set_command( + fields); + + // Publish our command +@@ -114259,11 +120028,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_setpoint_raise_or_lower_comman + false); + } + /** +- * @brief Publishes an incoming/generated GetWeeklyScheduleResponse command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated StopMoveStep command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetWeeklyScheduleResponse ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StopMoveStep + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114273,19 +120042,19 @@ void uic_mqtt_dotdot_thermostat_publish_generated_setpoint_raise_or_lower_comman + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_response_command( ++void uic_mqtt_dotdot_color_control_publish_generated_stop_move_step_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_thermostat_command_get_weekly_schedule_response_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_stop_move_step_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/GetWeeklyScheduleResponse"; ++ topic += "ColorControl/GeneratedCommands/StopMoveStep"; + + std::string payload = +- get_json_payload_for_thermostat_get_weekly_schedule_response_command( ++ get_json_payload_for_color_control_stop_move_step_command( + fields); + + // Publish our command +@@ -114295,11 +120064,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_response_c + false); + } + /** +- * @brief Publishes an incoming/generated SetWeeklySchedule command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated MoveColorTemperature command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/SetWeeklySchedule ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveColorTemperature + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114309,19 +120078,19 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_response_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_set_weekly_schedule_command( ++void uic_mqtt_dotdot_color_control_publish_generated_move_color_temperature_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_thermostat_command_set_weekly_schedule_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_move_color_temperature_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/SetWeeklySchedule"; ++ topic += "ColorControl/GeneratedCommands/MoveColorTemperature"; + + std::string payload = +- get_json_payload_for_thermostat_set_weekly_schedule_command( ++ get_json_payload_for_color_control_move_color_temperature_command( + fields); + + // Publish our command +@@ -114331,11 +120100,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_set_weekly_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetRelayStatusLogResponse command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated StepColorTemperature command for ++ * the ColorControl cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetRelayStatusLogResponse ++ * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepColorTemperature + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114345,19 +120114,19 @@ void uic_mqtt_dotdot_thermostat_publish_generated_set_weekly_schedule_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_response_command( ++void uic_mqtt_dotdot_color_control_publish_generated_step_color_temperature_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_thermostat_command_get_relay_status_log_response_fields_t *fields ++ const uic_mqtt_dotdot_color_control_command_step_color_temperature_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/GetRelayStatusLogResponse"; ++ topic += "ColorControl/GeneratedCommands/StepColorTemperature"; + + std::string payload = +- get_json_payload_for_thermostat_get_relay_status_log_response_command( ++ get_json_payload_for_color_control_step_color_temperature_command( + fields); + + // Publish our command +@@ -114367,11 +120136,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_response_ + false); + } + /** +- * @brief Publishes an incoming/generated GetWeeklySchedule command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated ZoneEnrollResponse command for ++ * the IASZone cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetWeeklySchedule ++ * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneEnrollResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114381,19 +120150,19 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_response_ + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_command( ++void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_thermostat_command_get_weekly_schedule_fields_t *fields ++ const uic_mqtt_dotdot_ias_zone_command_zone_enroll_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/GetWeeklySchedule"; ++ topic += "IASZone/GeneratedCommands/ZoneEnrollResponse"; + + std::string payload = +- get_json_payload_for_thermostat_get_weekly_schedule_command( ++ get_json_payload_for_ias_zone_zone_enroll_response_command( + fields); + + // Publish our command +@@ -114403,30 +120172,34 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_weekly_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated ClearWeeklySchedule command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated ZoneStatusChangeNotification command for ++ * the IASZone cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/ClearWeeklySchedule ++ * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneStatusChangeNotification + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_clear_weekly_schedule_command( ++void uic_mqtt_dotdot_ias_zone_publish_generated_zone_status_change_notification_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_ias_zone_command_zone_status_change_notification_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/ClearWeeklySchedule"; ++ topic += "IASZone/GeneratedCommands/ZoneStatusChangeNotification"; + + std::string payload = +- get_json_payload_for_thermostat_clear_weekly_schedule_command( +- ); ++ get_json_payload_for_ias_zone_zone_status_change_notification_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114435,11 +120208,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_clear_weekly_schedule_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetRelayStatusLog command for +- * the Thermostat cluster. ++ * @brief Publishes an incoming/generated InitiateNormalOperationMode command for ++ * the IASZone cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Thermostat/GeneratedCommands/GetRelayStatusLog ++ * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/InitiateNormalOperationMode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114447,17 +120220,17 @@ void uic_mqtt_dotdot_thermostat_publish_generated_clear_weekly_schedule_command( + * + * + */ +-void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_command( ++void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_normal_operation_mode_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Thermostat/GeneratedCommands/GetRelayStatusLog"; ++ topic += "IASZone/GeneratedCommands/InitiateNormalOperationMode"; + + std::string payload = +- get_json_payload_for_thermostat_get_relay_status_log_command( ++ get_json_payload_for_ias_zone_initiate_normal_operation_mode_command( + ); + + // Publish our command +@@ -114467,11 +120240,11 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated ZoneEnrollRequest command for ++ * the IASZone cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToHue ++ * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneEnrollRequest + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114481,19 +120254,19 @@ void uic_mqtt_dotdot_thermostat_publish_generated_get_relay_status_log_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_command( ++void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_request_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_to_hue_fields_t *fields ++ const uic_mqtt_dotdot_ias_zone_command_zone_enroll_request_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveToHue"; ++ topic += "IASZone/GeneratedCommands/ZoneEnrollRequest"; + + std::string payload = +- get_json_payload_for_color_control_move_to_hue_command( ++ get_json_payload_for_ias_zone_zone_enroll_request_command( + fields); + + // Publish our command +@@ -114503,11 +120276,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated InitiateTestMode command for ++ * the IASZone cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveHue ++ * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/InitiateTestMode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114517,19 +120290,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_hue_command( ++void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_test_mode_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_hue_fields_t *fields ++ const uic_mqtt_dotdot_ias_zone_command_initiate_test_mode_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveHue"; ++ topic += "IASZone/GeneratedCommands/InitiateTestMode"; + + std::string payload = +- get_json_payload_for_color_control_move_hue_command( ++ get_json_payload_for_ias_zone_initiate_test_mode_command( + fields); + + // Publish our command +@@ -114539,11 +120312,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_hue_command( + false); + } + /** +- * @brief Publishes an incoming/generated StepHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated StartWarning command for ++ * the IASWD cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepHue ++ * ucl/by-unid/UNID/epID/IASWD/GeneratedCommands/StartWarning + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114553,19 +120326,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_hue_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_step_hue_command( ++void uic_mqtt_dotdot_iaswd_publish_generated_start_warning_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_step_hue_fields_t *fields ++ const uic_mqtt_dotdot_iaswd_command_start_warning_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/StepHue"; ++ topic += "IASWD/GeneratedCommands/StartWarning"; + + std::string payload = +- get_json_payload_for_color_control_step_hue_command( ++ get_json_payload_for_iaswd_start_warning_command( + fields); + + // Publish our command +@@ -114575,11 +120348,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_hue_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToSaturation command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated Squawk command for ++ * the IASWD cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToSaturation ++ * ucl/by-unid/UNID/epID/IASWD/GeneratedCommands/Squawk + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114589,19 +120362,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_hue_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_to_saturation_command( ++void uic_mqtt_dotdot_iaswd_publish_generated_squawk_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_to_saturation_fields_t *fields ++ const uic_mqtt_dotdot_iaswd_command_squawk_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveToSaturation"; ++ topic += "IASWD/GeneratedCommands/Squawk"; + + std::string payload = +- get_json_payload_for_color_control_move_to_saturation_command( ++ get_json_payload_for_iaswd_squawk_command( + fields); + + // Publish our command +@@ -114611,11 +120384,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_saturation_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveSaturation command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated GetProfileInfoResponse command for ++ * the ElectricalMeasurement cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveSaturation ++ * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetProfileInfoResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114625,19 +120398,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_saturation_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_saturation_command( ++void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_saturation_fields_t *fields ++ const uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveSaturation"; ++ topic += "ElectricalMeasurement/GeneratedCommands/GetProfileInfoResponse"; + + std::string payload = +- get_json_payload_for_color_control_move_saturation_command( ++ get_json_payload_for_electrical_measurement_get_profile_info_response_command( + fields); + + // Publish our command +@@ -114647,34 +120420,30 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_saturation_command( + false); + } + /** +- * @brief Publishes an incoming/generated StepSaturation command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated GetProfileInfo command for ++ * the ElectricalMeasurement cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepSaturation ++ * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetProfileInfo + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_step_saturation_command( ++void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_step_saturation_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/StepSaturation"; ++ topic += "ElectricalMeasurement/GeneratedCommands/GetProfileInfo"; + + std::string payload = +- get_json_payload_for_color_control_step_saturation_command( +- fields); ++ get_json_payload_for_electrical_measurement_get_profile_info_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114683,11 +120452,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_saturation_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToHueAndSaturation command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated GetMeasurementProfileResponse command for ++ * the ElectricalMeasurement cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToHueAndSaturation ++ * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetMeasurementProfileResponse + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114697,19 +120466,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_saturation_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_and_saturation_command( ++void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_profile_response_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_to_hue_and_saturation_fields_t *fields ++ const uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveToHueAndSaturation"; ++ topic += "ElectricalMeasurement/GeneratedCommands/GetMeasurementProfileResponse"; + + std::string payload = +- get_json_payload_for_color_control_move_to_hue_and_saturation_command( ++ get_json_payload_for_electrical_measurement_get_measurement_profile_response_command( + fields); + + // Publish our command +@@ -114719,11 +120488,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_and_saturation_ + false); + } + /** +- * @brief Publishes an incoming/generated MoveToColor command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated GetMeasurementProfile command for ++ * the ElectricalMeasurement cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToColor ++ * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetMeasurementProfile + * + * @param unid The UNID of the node that sent us the command. + * +@@ -114733,19 +120502,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_hue_and_saturation_ + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_command( ++void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_profile_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_to_color_fields_t *fields ++ const uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveToColor"; ++ topic += "ElectricalMeasurement/GeneratedCommands/GetMeasurementProfile"; + + std::string payload = +- get_json_payload_for_color_control_move_to_color_command( ++ get_json_payload_for_electrical_measurement_get_measurement_profile_command( + fields); + + // Publish our command +@@ -114755,33 +120524,29 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveColor command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated TxReport command for ++ * the ProtocolController-RFTelemetry cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveColor ++ * ucl/by-unid/UNID/ProtocolController/RFTelemetry/GeneratedCommands/TxReport + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * + * + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_color_command( ++void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_generated_tx_report_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_color_fields_t *fields ++ const uic_mqtt_dotdot_protocol_controller_rf_telemetry_command_tx_report_fields_t *fields + + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveColor"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "ProtocolController/RFTelemetry/GeneratedCommands/TxReport"; + + std::string payload = +- get_json_payload_for_color_control_move_color_command( ++ get_json_payload_for_protocol_controller_rf_telemetry_tx_report_command( + fields); + + // Publish our command +@@ -114791,34 +120556,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_color_command( + false); + } + /** +- * @brief Publishes an incoming/generated StepColor command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated Remove command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepColor ++ * ucl/by-unid/UNID/State/GeneratedCommands/Remove + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_step_color_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_step_color_fields_t *fields +- ++void uic_mqtt_dotdot_state_publish_generated_remove_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/StepColor"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/Remove"; + + std::string payload = +- get_json_payload_for_color_control_step_color_command( +- fields); ++ get_json_payload_for_state_remove_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114827,34 +120584,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_color_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveToColorTemperature command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated RemoveOffline command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveToColorTemperature ++ * ucl/by-unid/UNID/State/GeneratedCommands/RemoveOffline + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command +- * +- */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_temperature_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_to_color_temperature_fields_t *fields +- ++ * ++ */ ++void uic_mqtt_dotdot_state_publish_generated_remove_offline_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveToColorTemperature"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/RemoveOffline"; + + std::string payload = +- get_json_payload_for_color_control_move_to_color_temperature_command( +- fields); ++ get_json_payload_for_state_remove_offline_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114863,34 +120612,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_to_color_temperature_c + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedMoveToHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated DiscoverNeighbors command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveToHue ++ * ucl/by-unid/UNID/State/GeneratedCommands/DiscoverNeighbors + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_enhanced_move_to_hue_fields_t *fields +- ++void uic_mqtt_dotdot_state_publish_generated_discover_neighbors_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/EnhancedMoveToHue"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/DiscoverNeighbors"; + + std::string payload = +- get_json_payload_for_color_control_enhanced_move_to_hue_command( +- fields); ++ get_json_payload_for_state_discover_neighbors_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114899,34 +120640,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_comman + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedMoveHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated Interview command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveHue ++ * ucl/by-unid/UNID/State/GeneratedCommands/Interview + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_hue_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_enhanced_move_hue_fields_t *fields +- ++void uic_mqtt_dotdot_state_publish_generated_interview_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/EnhancedMoveHue"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/Interview"; + + std::string payload = +- get_json_payload_for_color_control_enhanced_move_hue_command( +- fields); ++ get_json_payload_for_state_interview_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114935,34 +120668,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_hue_command( + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedStepHue command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated DiscoverSecurity command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedStepHue ++ * ucl/by-unid/UNID/State/GeneratedCommands/DiscoverSecurity + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_enhanced_step_hue_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_enhanced_step_hue_fields_t *fields +- ++void uic_mqtt_dotdot_state_publish_generated_discover_security_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/EnhancedStepHue"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/DiscoverSecurity"; + + std::string payload = +- get_json_payload_for_color_control_enhanced_step_hue_command( +- fields); ++ get_json_payload_for_state_discover_security_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -114971,34 +120696,26 @@ void uic_mqtt_dotdot_color_control_publish_generated_enhanced_step_hue_command( + false); + } + /** +- * @brief Publishes an incoming/generated EnhancedMoveToHueAndSaturation command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated EnableNls command for ++ * the State cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/EnhancedMoveToHueAndSaturation ++ * ucl/by-unid/UNID/State/GeneratedCommands/EnableNls + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * +- * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_and_saturation_command( +- const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_enhanced_move_to_hue_and_saturation_fields_t *fields +- ++void uic_mqtt_dotdot_state_publish_generated_enable_nls_command( ++ const dotdot_unid_t unid + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/EnhancedMoveToHueAndSaturation"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "State/GeneratedCommands/EnableNls"; + + std::string payload = +- get_json_payload_for_color_control_enhanced_move_to_hue_and_saturation_command( +- fields); ++ get_json_payload_for_state_enable_nls_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115007,11 +120724,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_and_sa + false); + } + /** +- * @brief Publishes an incoming/generated ColorLoopSet command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated Bind command for ++ * the Binding cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/ColorLoopSet ++ * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/Bind + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115021,19 +120738,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_enhanced_move_to_hue_and_sa + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_color_loop_set_command( ++void uic_mqtt_dotdot_binding_publish_generated_bind_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_color_loop_set_fields_t *fields ++ const uic_mqtt_dotdot_binding_command_bind_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/ColorLoopSet"; ++ topic += "Binding/GeneratedCommands/Bind"; + + std::string payload = +- get_json_payload_for_color_control_color_loop_set_command( ++ get_json_payload_for_binding_bind_command( + fields); + + // Publish our command +@@ -115043,11 +120760,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_color_loop_set_command( + false); + } + /** +- * @brief Publishes an incoming/generated StopMoveStep command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated Unbind command for ++ * the Binding cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StopMoveStep ++ * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/Unbind + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115057,19 +120774,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_color_loop_set_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_stop_move_step_command( ++void uic_mqtt_dotdot_binding_publish_generated_unbind_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_stop_move_step_fields_t *fields ++ const uic_mqtt_dotdot_binding_command_unbind_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/StopMoveStep"; ++ topic += "Binding/GeneratedCommands/Unbind"; + + std::string payload = +- get_json_payload_for_color_control_stop_move_step_command( ++ get_json_payload_for_binding_unbind_command( + fields); + + // Publish our command +@@ -115079,11 +120796,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_stop_move_step_command( + false); + } + /** +- * @brief Publishes an incoming/generated MoveColorTemperature command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated BindToProtocolController command for ++ * the Binding cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/MoveColorTemperature ++ * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/BindToProtocolController + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115093,19 +120810,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_stop_move_step_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_move_color_temperature_command( ++void uic_mqtt_dotdot_binding_publish_generated_bind_to_protocol_controller_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_move_color_temperature_fields_t *fields ++ const uic_mqtt_dotdot_binding_command_bind_to_protocol_controller_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/MoveColorTemperature"; ++ topic += "Binding/GeneratedCommands/BindToProtocolController"; + + std::string payload = +- get_json_payload_for_color_control_move_color_temperature_command( ++ get_json_payload_for_binding_bind_to_protocol_controller_command( + fields); + + // Publish our command +@@ -115115,11 +120832,11 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_color_temperature_comm + false); + } + /** +- * @brief Publishes an incoming/generated StepColorTemperature command for +- * the ColorControl cluster. ++ * @brief Publishes an incoming/generated UnbindFromProtocolController command for ++ * the Binding cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ColorControl/GeneratedCommands/StepColorTemperature ++ * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/UnbindFromProtocolController + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115129,19 +120846,19 @@ void uic_mqtt_dotdot_color_control_publish_generated_move_color_temperature_comm + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_color_control_publish_generated_step_color_temperature_command( ++void uic_mqtt_dotdot_binding_publish_generated_unbind_from_protocol_controller_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_color_control_command_step_color_temperature_fields_t *fields ++ const uic_mqtt_dotdot_binding_command_unbind_from_protocol_controller_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ColorControl/GeneratedCommands/StepColorTemperature"; ++ topic += "Binding/GeneratedCommands/UnbindFromProtocolController"; + + std::string payload = +- get_json_payload_for_color_control_step_color_temperature_command( ++ get_json_payload_for_binding_unbind_from_protocol_controller_command( + fields); + + // Publish our command +@@ -115151,33 +120868,29 @@ void uic_mqtt_dotdot_color_control_publish_generated_step_color_temperature_comm + false); + } + /** +- * @brief Publishes an incoming/generated ZoneEnrollResponse command for +- * the IASZone cluster. ++ * @brief Publishes an incoming/generated LogEntry command for ++ * the ApplicationMonitoring cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneEnrollResponse ++ * ucl/by-unid/UNID/ApplicationMonitoring/GeneratedCommands/LogEntry + * + * @param unid The UNID of the node that sent us the command. + * +- * @param endpoint The Endpoint ID of the node that sent us the command. +- * + * + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_response_command( ++void uic_mqtt_dotdot_application_monitoring_publish_generated_log_entry_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_ias_zone_command_zone_enroll_response_fields_t *fields ++ const uic_mqtt_dotdot_application_monitoring_command_log_entry_fields_t *fields + + ) { + // Create the topic +- std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + +- std::to_string(endpoint) + "/"; +- topic += "IASZone/GeneratedCommands/ZoneEnrollResponse"; ++ std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; ++ topic += "ApplicationMonitoring/GeneratedCommands/LogEntry"; + + std::string payload = +- get_json_payload_for_ias_zone_zone_enroll_response_command( ++ get_json_payload_for_application_monitoring_log_entry_command( + fields); + + // Publish our command +@@ -115187,11 +120900,11 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_response_command( + false); + } + /** +- * @brief Publishes an incoming/generated ZoneStatusChangeNotification command for +- * the IASZone cluster. ++ * @brief Publishes an incoming/generated DiscoverParameter command for ++ * the ConfigurationParameters cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneStatusChangeNotification ++ * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DiscoverParameter + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115201,19 +120914,19 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_response_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_ias_zone_publish_generated_zone_status_change_notification_command( ++void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_parameter_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_ias_zone_command_zone_status_change_notification_fields_t *fields ++ const uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASZone/GeneratedCommands/ZoneStatusChangeNotification"; ++ topic += "ConfigurationParameters/GeneratedCommands/DiscoverParameter"; + + std::string payload = +- get_json_payload_for_ias_zone_zone_status_change_notification_command( ++ get_json_payload_for_configuration_parameters_discover_parameter_command( + fields); + + // Publish our command +@@ -115223,11 +120936,11 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_status_change_notification_ + false); + } + /** +- * @brief Publishes an incoming/generated InitiateNormalOperationMode command for +- * the IASZone cluster. ++ * @brief Publishes an incoming/generated DefaultResetAllParameters command for ++ * the ConfigurationParameters cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/InitiateNormalOperationMode ++ * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DefaultResetAllParameters + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115235,17 +120948,17 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_status_change_notification_ + * + * + */ +-void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_normal_operation_mode_command( ++void uic_mqtt_dotdot_configuration_parameters_publish_generated_default_reset_all_parameters_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASZone/GeneratedCommands/InitiateNormalOperationMode"; ++ topic += "ConfigurationParameters/GeneratedCommands/DefaultResetAllParameters"; + + std::string payload = +- get_json_payload_for_ias_zone_initiate_normal_operation_mode_command( ++ get_json_payload_for_configuration_parameters_default_reset_all_parameters_command( + ); + + // Publish our command +@@ -115255,11 +120968,11 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_normal_operation_mode_c + false); + } + /** +- * @brief Publishes an incoming/generated ZoneEnrollRequest command for +- * the IASZone cluster. ++ * @brief Publishes an incoming/generated SetParameter command for ++ * the ConfigurationParameters cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/ZoneEnrollRequest ++ * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/SetParameter + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115269,19 +120982,19 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_normal_operation_mode_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_request_command( ++void uic_mqtt_dotdot_configuration_parameters_publish_generated_set_parameter_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_ias_zone_command_zone_enroll_request_fields_t *fields ++ const uic_mqtt_dotdot_configuration_parameters_command_set_parameter_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASZone/GeneratedCommands/ZoneEnrollRequest"; ++ topic += "ConfigurationParameters/GeneratedCommands/SetParameter"; + + std::string payload = +- get_json_payload_for_ias_zone_zone_enroll_request_command( ++ get_json_payload_for_configuration_parameters_set_parameter_command( + fields); + + // Publish our command +@@ -115291,11 +121004,11 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_request_command( + false); + } + /** +- * @brief Publishes an incoming/generated InitiateTestMode command for +- * the IASZone cluster. ++ * @brief Publishes an incoming/generated DiscoverParameterRange command for ++ * the ConfigurationParameters cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASZone/GeneratedCommands/InitiateTestMode ++ * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DiscoverParameterRange + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115305,19 +121018,19 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_zone_enroll_request_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_test_mode_command( ++void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_parameter_range_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_ias_zone_command_initiate_test_mode_fields_t *fields ++ const uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASZone/GeneratedCommands/InitiateTestMode"; ++ topic += "ConfigurationParameters/GeneratedCommands/DiscoverParameterRange"; + + std::string payload = +- get_json_payload_for_ias_zone_initiate_test_mode_command( ++ get_json_payload_for_configuration_parameters_discover_parameter_range_command( + fields); + + // Publish our command +@@ -115327,11 +121040,11 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_test_mode_command( + false); + } + /** +- * @brief Publishes an incoming/generated StartWarning command for +- * the IASWD cluster. ++ * @brief Publishes an incoming/generated AddUser command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASWD/GeneratedCommands/StartWarning ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115341,19 +121054,19 @@ void uic_mqtt_dotdot_ias_zone_publish_generated_initiate_test_mode_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_iaswd_publish_generated_start_warning_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_add_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_iaswd_command_start_warning_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASWD/GeneratedCommands/StartWarning"; ++ topic += "UserCredential/GeneratedCommands/AddUser"; + + std::string payload = +- get_json_payload_for_iaswd_start_warning_command( ++ get_json_payload_for_user_credential_add_user_command( + fields); + + // Publish our command +@@ -115363,11 +121076,11 @@ void uic_mqtt_dotdot_iaswd_publish_generated_start_warning_command( + false); + } + /** +- * @brief Publishes an incoming/generated Squawk command for +- * the IASWD cluster. ++ * @brief Publishes an incoming/generated ModifyUser command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/IASWD/GeneratedCommands/Squawk ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115377,19 +121090,19 @@ void uic_mqtt_dotdot_iaswd_publish_generated_start_warning_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_iaswd_publish_generated_squawk_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_iaswd_command_squawk_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "IASWD/GeneratedCommands/Squawk"; ++ topic += "UserCredential/GeneratedCommands/ModifyUser"; + + std::string payload = +- get_json_payload_for_iaswd_squawk_command( ++ get_json_payload_for_user_credential_modify_user_command( + fields); + + // Publish our command +@@ -115399,11 +121112,11 @@ void uic_mqtt_dotdot_iaswd_publish_generated_squawk_command( + false); + } + /** +- * @brief Publishes an incoming/generated GetProfileInfoResponse command for +- * the ElectricalMeasurement cluster. ++ * @brief Publishes an incoming/generated DeleteUser command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetProfileInfoResponse ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteUser + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115413,19 +121126,19 @@ void uic_mqtt_dotdot_iaswd_publish_generated_squawk_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_response_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_user_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ElectricalMeasurement/GeneratedCommands/GetProfileInfoResponse"; ++ topic += "UserCredential/GeneratedCommands/DeleteUser"; + + std::string payload = +- get_json_payload_for_electrical_measurement_get_profile_info_response_command( ++ get_json_payload_for_user_credential_delete_user_command( + fields); + + // Publish our command +@@ -115435,30 +121148,34 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_r + false); + } + /** +- * @brief Publishes an incoming/generated GetProfileInfo command for +- * the ElectricalMeasurement cluster. ++ * @brief Publishes an incoming/generated AddCredential command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetProfileInfo ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddCredential + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * ++ * @param fields Struct pointer with the fields value of the command ++ * + */ +-void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_add_credential_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ElectricalMeasurement/GeneratedCommands/GetProfileInfo"; ++ topic += "UserCredential/GeneratedCommands/AddCredential"; + + std::string payload = +- get_json_payload_for_electrical_measurement_get_profile_info_command( +- ); ++ get_json_payload_for_user_credential_add_credential_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115467,11 +121184,11 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_c + false); + } + /** +- * @brief Publishes an incoming/generated GetMeasurementProfileResponse command for +- * the ElectricalMeasurement cluster. ++ * @brief Publishes an incoming/generated ModifyCredential command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetMeasurementProfileResponse ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyCredential + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115481,19 +121198,19 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_profile_info_c + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_profile_response_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_credential_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ElectricalMeasurement/GeneratedCommands/GetMeasurementProfileResponse"; ++ topic += "UserCredential/GeneratedCommands/ModifyCredential"; + + std::string payload = +- get_json_payload_for_electrical_measurement_get_measurement_profile_response_command( ++ get_json_payload_for_user_credential_modify_credential_command( + fields); + + // Publish our command +@@ -115503,11 +121220,11 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_pr + false); + } + /** +- * @brief Publishes an incoming/generated GetMeasurementProfile command for +- * the ElectricalMeasurement cluster. ++ * @brief Publishes an incoming/generated DeleteCredential command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ElectricalMeasurement/GeneratedCommands/GetMeasurementProfile ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteCredential + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115517,19 +121234,19 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_pr + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_profile_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_credential_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ElectricalMeasurement/GeneratedCommands/GetMeasurementProfile"; ++ topic += "UserCredential/GeneratedCommands/DeleteCredential"; + + std::string payload = +- get_json_payload_for_electrical_measurement_get_measurement_profile_command( ++ get_json_payload_for_user_credential_delete_credential_command( + fields); + + // Publish our command +@@ -115539,30 +121256,30 @@ void uic_mqtt_dotdot_electrical_measurement_publish_generated_get_measurement_pr + false); + } + /** +- * @brief Publishes an incoming/generated TxReport command for +- * the ProtocolController-RFTelemetry cluster. ++ * @brief Publishes an incoming/generated DeleteAllUsers command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/ProtocolController/RFTelemetry/GeneratedCommands/TxReport ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllUsers + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. + * +- * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_generated_tx_report_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_users_command( + const dotdot_unid_t unid, +- const uic_mqtt_dotdot_protocol_controller_rf_telemetry_command_tx_report_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "ProtocolController/RFTelemetry/GeneratedCommands/TxReport"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllUsers"; + + std::string payload = +- get_json_payload_for_protocol_controller_rf_telemetry_tx_report_command( +- fields); ++ get_json_payload_for_user_credential_delete_all_users_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115571,25 +121288,29 @@ void uic_mqtt_dotdot_protocol_controller_rf_telemetry_publish_generated_tx_repor + false); + } + /** +- * @brief Publishes an incoming/generated Remove command for +- * the State cluster. ++ * @brief Publishes an incoming/generated DeleteAllCredentials command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/Remove ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentials + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * + * + */ +-void uic_mqtt_dotdot_state_publish_generated_remove_command( +- const dotdot_unid_t unid ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/Remove"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentials"; + + std::string payload = +- get_json_payload_for_state_remove_command( ++ get_json_payload_for_user_credential_delete_all_credentials_command( + ); + + // Publish our command +@@ -115599,54 +121320,34 @@ void uic_mqtt_dotdot_state_publish_generated_remove_command( + false); + } + /** +- * @brief Publishes an incoming/generated RemoveOffline command for +- * the State cluster. ++ * @brief Publishes an incoming/generated DeleteAllCredentialsByType command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/RemoveOffline ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsByType + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. + * +- */ +-void uic_mqtt_dotdot_state_publish_generated_remove_offline_command( +- const dotdot_unid_t unid +-) { +- // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/RemoveOffline"; +- +- std::string payload = +- get_json_payload_for_state_remove_offline_command( +- ); +- +- // Publish our command +- uic_mqtt_publish(topic.c_str(), +- payload.c_str(), +- payload.size(), +- false); +-} +-/** +- * @brief Publishes an incoming/generated DiscoverNeighbors command for +- * the State cluster. +- * +- * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/DiscoverNeighbors +- * +- * @param unid The UNID of the node that sent us the command. + * ++ * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_state_publish_generated_discover_neighbors_command( +- const dotdot_unid_t unid ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/DiscoverNeighbors"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsByType"; + + std::string payload = +- get_json_payload_for_state_discover_neighbors_command( +- ); ++ get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115655,54 +121356,34 @@ void uic_mqtt_dotdot_state_publish_generated_discover_neighbors_command( + false); + } + /** +- * @brief Publishes an incoming/generated Interview command for +- * the State cluster. ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUser command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/Interview ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUser + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. + * +- */ +-void uic_mqtt_dotdot_state_publish_generated_interview_command( +- const dotdot_unid_t unid +-) { +- // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/Interview"; +- +- std::string payload = +- get_json_payload_for_state_interview_command( +- ); +- +- // Publish our command +- uic_mqtt_publish(topic.c_str(), +- payload.c_str(), +- payload.size(), +- false); +-} +-/** +- * @brief Publishes an incoming/generated DiscoverSecurity command for +- * the State cluster. +- * +- * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/DiscoverSecurity +- * +- * @param unid The UNID of the node that sent us the command. + * ++ * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_state_publish_generated_discover_security_command( +- const dotdot_unid_t unid ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/DiscoverSecurity"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsForUser"; + + std::string payload = +- get_json_payload_for_state_discover_security_command( +- ); ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115711,26 +121392,34 @@ void uic_mqtt_dotdot_state_publish_generated_discover_security_command( + false); + } + /** +- * @brief Publishes an incoming/generated EnableNls command for +- * the State cluster. ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/State/GeneratedCommands/EnableNls ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_state_publish_generated_enable_nls_command( +- const dotdot_unid_t unid ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "State/GeneratedCommands/EnableNls"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType"; + + std::string payload = +- get_json_payload_for_state_enable_nls_command( +- ); ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ fields); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115739,11 +121428,11 @@ void uic_mqtt_dotdot_state_publish_generated_enable_nls_command( + false); + } + /** +- * @brief Publishes an incoming/generated Bind command for +- * the Binding cluster. ++ * @brief Publishes an incoming/generated CredentialLearnStartAdd command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/Bind ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartAdd + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115753,19 +121442,19 @@ void uic_mqtt_dotdot_state_publish_generated_enable_nls_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_binding_publish_generated_bind_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_add_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_binding_command_bind_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Binding/GeneratedCommands/Bind"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStartAdd"; + + std::string payload = +- get_json_payload_for_binding_bind_command( ++ get_json_payload_for_user_credential_credential_learn_start_add_command( + fields); + + // Publish our command +@@ -115775,11 +121464,11 @@ void uic_mqtt_dotdot_binding_publish_generated_bind_command( + false); + } + /** +- * @brief Publishes an incoming/generated Unbind command for +- * the Binding cluster. ++ * @brief Publishes an incoming/generated CredentialLearnStartModify command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/Unbind ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartModify + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115789,19 +121478,19 @@ void uic_mqtt_dotdot_binding_publish_generated_bind_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_binding_publish_generated_unbind_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_modify_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_binding_command_unbind_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Binding/GeneratedCommands/Unbind"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStartModify"; + + std::string payload = +- get_json_payload_for_binding_unbind_command( ++ get_json_payload_for_user_credential_credential_learn_start_modify_command( + fields); + + // Publish our command +@@ -115811,34 +121500,30 @@ void uic_mqtt_dotdot_binding_publish_generated_unbind_command( + false); + } + /** +- * @brief Publishes an incoming/generated BindToProtocolController command for +- * the Binding cluster. ++ * @brief Publishes an incoming/generated CredentialLearnStop command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/BindToProtocolController ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStop + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_binding_publish_generated_bind_to_protocol_controller_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_stop_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_binding_command_bind_to_protocol_controller_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Binding/GeneratedCommands/BindToProtocolController"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStop"; + + std::string payload = +- get_json_payload_for_binding_bind_to_protocol_controller_command( +- fields); ++ get_json_payload_for_user_credential_credential_learn_stop_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +@@ -115847,11 +121532,11 @@ void uic_mqtt_dotdot_binding_publish_generated_bind_to_protocol_controller_comma + false); + } + /** +- * @brief Publishes an incoming/generated UnbindFromProtocolController command for +- * the Binding cluster. ++ * @brief Publishes an incoming/generated CredentialAssociation command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/Binding/GeneratedCommands/UnbindFromProtocolController ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialAssociation + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115861,19 +121546,19 @@ void uic_mqtt_dotdot_binding_publish_generated_bind_to_protocol_controller_comma + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_binding_publish_generated_unbind_from_protocol_controller_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_association_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_binding_command_unbind_from_protocol_controller_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "Binding/GeneratedCommands/UnbindFromProtocolController"; ++ topic += "UserCredential/GeneratedCommands/CredentialAssociation"; + + std::string payload = +- get_json_payload_for_binding_unbind_from_protocol_controller_command( ++ get_json_payload_for_user_credential_credential_association_command( + fields); + + // Publish our command +@@ -115883,29 +121568,33 @@ void uic_mqtt_dotdot_binding_publish_generated_unbind_from_protocol_controller_c + false); + } + /** +- * @brief Publishes an incoming/generated LogEntry command for +- * the ApplicationMonitoring cluster. ++ * @brief Publishes an incoming/generated GetUserChecksum command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/ApplicationMonitoring/GeneratedCommands/LogEntry ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetUserChecksum + * + * @param unid The UNID of the node that sent us the command. + * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * + * + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_application_monitoring_publish_generated_log_entry_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_get_user_checksum_command( + const dotdot_unid_t unid, +- const uic_mqtt_dotdot_application_monitoring_command_log_entry_fields_t *fields ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields + + ) { + // Create the topic +- std::string topic = "ucl/by-unid/" + std::string(unid) + "/"; +- topic += "ApplicationMonitoring/GeneratedCommands/LogEntry"; ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/GetUserChecksum"; + + std::string payload = +- get_json_payload_for_application_monitoring_log_entry_command( ++ get_json_payload_for_user_credential_get_user_checksum_command( + fields); + + // Publish our command +@@ -115915,11 +121604,11 @@ void uic_mqtt_dotdot_application_monitoring_publish_generated_log_entry_command( + false); + } + /** +- * @brief Publishes an incoming/generated DiscoverParameter command for +- * the ConfigurationParameters cluster. ++ * @brief Publishes an incoming/generated GetCredentialChecksum command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DiscoverParameter ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetCredentialChecksum + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115929,19 +121618,19 @@ void uic_mqtt_dotdot_application_monitoring_publish_generated_log_entry_command( + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_parameter_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_get_credential_checksum_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ConfigurationParameters/GeneratedCommands/DiscoverParameter"; ++ topic += "UserCredential/GeneratedCommands/GetCredentialChecksum"; + + std::string payload = +- get_json_payload_for_configuration_parameters_discover_parameter_command( ++ get_json_payload_for_user_credential_get_credential_checksum_command( + fields); + + // Publish our command +@@ -115951,11 +121640,11 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_paramet + false); + } + /** +- * @brief Publishes an incoming/generated DefaultResetAllParameters command for +- * the ConfigurationParameters cluster. ++ * @brief Publishes an incoming/generated GetAllUsersChecksum command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DefaultResetAllParameters ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetAllUsersChecksum + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115963,17 +121652,17 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_paramet + * + * + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_generated_default_reset_all_parameters_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_get_all_users_checksum_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ConfigurationParameters/GeneratedCommands/DefaultResetAllParameters"; ++ topic += "UserCredential/GeneratedCommands/GetAllUsersChecksum"; + + std::string payload = +- get_json_payload_for_configuration_parameters_default_reset_all_parameters_command( ++ get_json_payload_for_user_credential_get_all_users_checksum_command( + ); + + // Publish our command +@@ -115983,11 +121672,11 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_default_reset_al + false); + } + /** +- * @brief Publishes an incoming/generated SetParameter command for +- * the ConfigurationParameters cluster. ++ * @brief Publishes an incoming/generated SetAdminPINCode command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/SetParameter ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/SetAdminPINCode + * + * @param unid The UNID of the node that sent us the command. + * +@@ -115997,19 +121686,19 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_default_reset_al + * @param fields Struct pointer with the fields value of the command + * + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_generated_set_parameter_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_set_admin_pin_code_command( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_configuration_parameters_command_set_parameter_fields_t *fields ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields + + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ConfigurationParameters/GeneratedCommands/SetParameter"; ++ topic += "UserCredential/GeneratedCommands/SetAdminPINCode"; + + std::string payload = +- get_json_payload_for_configuration_parameters_set_parameter_command( ++ get_json_payload_for_user_credential_set_admin_pin_code_command( + fields); + + // Publish our command +@@ -116019,34 +121708,30 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_set_parameter_co + false); + } + /** +- * @brief Publishes an incoming/generated DiscoverParameterRange command for +- * the ConfigurationParameters cluster. ++ * @brief Publishes an incoming/generated DeactivateAdminPINCode command for ++ * the UserCredential cluster. + * + * Publication will be made at the following topic +- * ucl/by-unid/UNID/epID/ConfigurationParameters/GeneratedCommands/DiscoverParameterRange ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeactivateAdminPINCode + * + * @param unid The UNID of the node that sent us the command. + * + * @param endpoint The Endpoint ID of the node that sent us the command. + * + * +- * @param fields Struct pointer with the fields value of the command +- * + */ +-void uic_mqtt_dotdot_configuration_parameters_publish_generated_discover_parameter_range_command( ++void uic_mqtt_dotdot_user_credential_publish_generated_deactivate_admin_pin_code_command( + const dotdot_unid_t unid, +- const dotdot_endpoint_id_t endpoint, +- const uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t *fields +- ++ const dotdot_endpoint_id_t endpoint + ) { + // Create the topic + std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + + std::to_string(endpoint) + "/"; +- topic += "ConfigurationParameters/GeneratedCommands/DiscoverParameterRange"; ++ topic += "UserCredential/GeneratedCommands/DeactivateAdminPINCode"; + + std::string payload = +- get_json_payload_for_configuration_parameters_discover_parameter_range_command( +- fields); ++ get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ); + + // Publish our command + uic_mqtt_publish(topic.c_str(), +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp +index 63ed3b0949..a954bd2658 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp +@@ -343,6 +343,13 @@ sl_status_t uic_mqtt_dotdot_by_group_name_and_location_init(); + */ + sl_status_t uic_mqtt_dotdot_by_group_configuration_parameters_init(); + ++/** ++ * @brief Initialize UserCredential dotdot bygroup command handlers ++ * ++ * @returns SL_STATUS_OK on success, error otherwise. ++ */ ++sl_status_t uic_mqtt_dotdot_by_group_user_credential_init(); ++ + /** + * @brief Initialize Descriptor dotdot bygroup command handlers + * +@@ -4915,6 +4922,407 @@ void uic_mqtt_dotdot_on_configuration_parameters_WriteAttributes( + const size_t message_length); + + ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/AddUser messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_add_user_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/AddUser ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_add_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/ModifyUser messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_modify_user_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/ModifyUser ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_modify_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteUser messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_user_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteUser ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/AddCredential messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_add_credential_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/AddCredential ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_add_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/ModifyCredential messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_modify_credential_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/ModifyCredential ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_modify_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteCredential messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_credential_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteCredential ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteAllUsers messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_all_users_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteAllUsers ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_all_users( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteAllCredentials messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentials ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteAllCredentialsByType messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsByType ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteAllCredentialsForUser messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsForUser ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeleteAllCredentialsForUserByType messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeleteAllCredentialsForUserByType ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/CredentialLearnStartAdd messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStartAdd ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_credential_learn_start_add( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/CredentialLearnStartModify messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStartModify ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_credential_learn_start_modify( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/CredentialLearnStop messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/CredentialLearnStop ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_credential_learn_stop( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/CredentialAssociation messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_credential_association_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/CredentialAssociation ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_credential_association( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/GetUserChecksum messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/GetUserChecksum ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_get_user_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/GetCredentialChecksum messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/GetCredentialChecksum ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_get_credential_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/GetAllUsersChecksum messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/GetAllUsersChecksum ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_get_all_users_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/SetAdminPINCode messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/SetAdminPINCode ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_set_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callbacks pointer for ++ * by-unid UserCredential/Commands/DeactivateAdminPINCode messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set &get_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/DeactivateAdminPINCode ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_deactivate_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++// clang-format on ++ ++/** ++ * @brief Retrieves the container with callback pointers for by-unid ++ * /Commands/WriteAttributes messages ++ * ++ * @returns std::set of callbacks. ++ */ ++std::set & get_uic_mqtt_dotdot_user_credential_write_attributes_callback(); ++ ++/** ++ * @brief MQTT Subscribe handler for incoming publications on: ++ * ucl/by-unid/+/+/UserCredential/Commands/WriteAttributes ++ */ ++// clang-format off ++void uic_mqtt_dotdot_on_user_credential_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length); ++ ++ + // clang-format on + + /** +@@ -5245,7 +5653,7 @@ const std::vector, std::vector, std::vector>>> DeviceTemperatureConfigurationDeviceTempAlarmMask_bitmap_data { + { {"DeviceTemperatureTooLow", "bool", "0x1", "0"}, { +@@ -5681,7 +6089,7 @@ const std::vector, std::vector, std::vector>>> PowerConfigurationMainsAlarmMask_bitmap_data { + { {"MainsVoltageTooLow", "bool", "0x1", "0"}, { +@@ -6038,6 +6446,60 @@ const std::vector, std::vector, std::vector>>> UserCredentialSupportedCredentialRules_bitmap_data { ++{ {"Single", "bool", "0x2", "1"}, { ++} }, ++{ {"Dual", "bool", "0x4", "2"}, { ++} }, ++{ {"Triple", "bool", "0x8", "3"}, { ++} } ++}; ++const dotdot_bitmap UserCredentialSupportedCredentialRules("UserCredentialSupportedCredentialRules", "map8", UserCredentialSupportedCredentialRules_bitmap_data); ++ ++const std::vector, std::vector>>> UserCredentialSupportedCredentialTypes_bitmap_data { ++{ {"PINCode", "bool", "0x1", "0"}, { ++} }, ++{ {"Password", "bool", "0x2", "1"}, { ++} }, ++{ {"RFIDCode", "bool", "0x4", "2"}, { ++} }, ++{ {"BLE", "bool", "0x8", "3"}, { ++} }, ++{ {"NFC", "bool", "0x10", "4"}, { ++} }, ++{ {"UWB", "bool", "0x20", "5"}, { ++} }, ++{ {"EyeBiometric", "bool", "0x40", "6"}, { ++} }, ++{ {"FaceBiometric", "bool", "0x80", "7"}, { ++} }, ++{ {"FingerBiometric", "bool", "0x100", "8"}, { ++} }, ++{ {"HandBiometric", "bool", "0x200", "9"}, { ++} }, ++{ {"UnspecifiedBiometric", "bool", "0x400", "10"}, { ++} } ++}; ++const dotdot_bitmap UserCredentialSupportedCredentialTypes("UserCredentialSupportedCredentialTypes", "map16", UserCredentialSupportedCredentialTypes_bitmap_data); ++ ++const std::vector, std::vector>>> UserCredentialSupportedUserTypes_bitmap_data { ++{ {"GeneralUser", "bool", "0x1", "0"}, { ++} }, ++{ {"ProgrammingUser", "bool", "0x8", "3"}, { ++} }, ++{ {"NonAccessUser", "bool", "0x10", "4"}, { ++} }, ++{ {"DuressUser", "bool", "0x20", "5"}, { ++} }, ++{ {"DisposableUser", "bool", "0x40", "6"}, { ++} }, ++{ {"ExpiringUser", "bool", "0x80", "7"}, { ++} }, ++{ {"RemoteOnlyUser", "bool", "0x200", "9"}, { ++} } ++}; ++const dotdot_bitmap UserCredentialSupportedUserTypes("UserCredentialSupportedUserTypes", "map16", UserCredentialSupportedUserTypes_bitmap_data); ++ + const std::vector, std::vector>>> WindowCoveringConfigOrStatus_bitmap_data { + { {"Operational", "bool", "0x1", "0"}, { + } }, +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp +index 51bb0cd1eb..200e293797 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp +@@ -135,7 +135,7 @@ static void uic_mqtt_dotdot_on_basic_zcl_version_attribute_update( + } + + +- uint8_t zcl_version = {}; ++ int8_t zcl_version = {}; + + nlohmann::json json_payload; + try { +@@ -148,7 +148,7 @@ static void uic_mqtt_dotdot_on_basic_zcl_version_attribute_update( + return; + } + // Start parsing value +- zcl_version = json_payload.at("value").get(); ++ zcl_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -211,7 +211,7 @@ static void uic_mqtt_dotdot_on_basic_application_version_attribute_update( + } + + +- uint8_t application_version = {}; ++ int8_t application_version = {}; + + nlohmann::json json_payload; + try { +@@ -224,7 +224,7 @@ static void uic_mqtt_dotdot_on_basic_application_version_attribute_update( + return; + } + // Start parsing value +- application_version = json_payload.at("value").get(); ++ application_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -287,7 +287,7 @@ static void uic_mqtt_dotdot_on_basic_stack_version_attribute_update( + } + + +- uint8_t stack_version = {}; ++ int8_t stack_version = {}; + + nlohmann::json json_payload; + try { +@@ -300,7 +300,7 @@ static void uic_mqtt_dotdot_on_basic_stack_version_attribute_update( + return; + } + // Start parsing value +- stack_version = json_payload.at("value").get(); ++ stack_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -363,7 +363,7 @@ static void uic_mqtt_dotdot_on_basic_hw_version_attribute_update( + } + + +- uint8_t hw_version = {}; ++ int8_t hw_version = {}; + + nlohmann::json json_payload; + try { +@@ -376,7 +376,7 @@ static void uic_mqtt_dotdot_on_basic_hw_version_attribute_update( + return; + } + // Start parsing value +- hw_version = json_payload.at("value").get(); ++ hw_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -919,7 +919,7 @@ static void uic_mqtt_dotdot_on_basic_product_code_attribute_update( + } + + +- const char* product_code = {}; ++ uint8_t product_code = {}; + + nlohmann::json json_payload; + try { +@@ -2015,7 +2015,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_attribute_updat + } + + +- uint16_t mains_voltage = {}; ++ int16_t mains_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2028,7 +2028,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_attribute_updat + return; + } + // Start parsing value +- mains_voltage = json_payload.at("value").get(); ++ mains_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -2091,7 +2091,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_frequency_attribute_upd + } + + +- uint8_t mains_frequency = {}; ++ int8_t mains_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -2104,7 +2104,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_frequency_attribute_upd + return; + } + // Start parsing value +- mains_frequency = json_payload.at("value").get(); ++ mains_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -2243,7 +2243,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_min_threshold_a + } + + +- uint16_t mains_voltage_min_threshold = {}; ++ int16_t mains_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -2256,7 +2256,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_min_threshold_a + return; + } + // Start parsing value +- mains_voltage_min_threshold = json_payload.at("value").get(); ++ mains_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -2319,7 +2319,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_max_threshold_a + } + + +- uint16_t mains_voltage_max_threshold = {}; ++ int16_t mains_voltage_max_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -2332,7 +2332,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_max_threshold_a + return; + } + // Start parsing value +- mains_voltage_max_threshold = json_payload.at("value").get(); ++ mains_voltage_max_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -2395,7 +2395,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_dwell_trip_poin + } + + +- uint16_t mains_voltage_dwell_trip_point = {}; ++ int16_t mains_voltage_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -2408,7 +2408,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_dwell_trip_poin + return; + } + // Start parsing value +- mains_voltage_dwell_trip_point = json_payload.at("value").get(); ++ mains_voltage_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -2471,7 +2471,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_attribute_upd + } + + +- uint8_t battery_voltage = {}; ++ int8_t battery_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2484,7 +2484,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_attribute_upd + return; + } + // Start parsing value +- battery_voltage = json_payload.at("value").get(); ++ battery_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -2547,7 +2547,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_remaining_ + } + + +- uint8_t battery_percentage_remaining = {}; ++ int8_t battery_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -2560,7 +2560,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_remaining_ + return; + } + // Start parsing value +- battery_percentage_remaining = json_payload.at("value").get(); ++ battery_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -2783,7 +2783,7 @@ static void uic_mqtt_dotdot_on_power_configuration_batterya_hr_rating_attribute_ + } + + +- uint16_t batterya_hr_rating = {}; ++ int16_t batterya_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -2796,7 +2796,7 @@ static void uic_mqtt_dotdot_on_power_configuration_batterya_hr_rating_attribute_ + return; + } + // Start parsing value +- batterya_hr_rating = json_payload.at("value").get(); ++ batterya_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -2859,7 +2859,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_quantity_attribute_up + } + + +- uint8_t battery_quantity = {}; ++ int8_t battery_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -2872,7 +2872,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_quantity_attribute_up + return; + } + // Start parsing value +- battery_quantity = json_payload.at("value").get(); ++ battery_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -2935,7 +2935,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_rated_voltage_attribu + } + + +- uint8_t battery_rated_voltage = {}; ++ int8_t battery_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2948,7 +2948,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_rated_voltage_attribu + return; + } + // Start parsing value +- battery_rated_voltage = json_payload.at("value").get(); ++ battery_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -3087,7 +3087,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_min_threshold + } + + +- uint8_t battery_voltage_min_threshold = {}; ++ int8_t battery_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -3100,7 +3100,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_min_threshold + return; + } + // Start parsing value +- battery_voltage_min_threshold = json_payload.at("value").get(); ++ battery_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -3163,7 +3163,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold1_at + } + + +- uint8_t battery_voltage_threshold1 = {}; ++ int8_t battery_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -3176,7 +3176,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold1_at + return; + } + // Start parsing value +- battery_voltage_threshold1 = json_payload.at("value").get(); ++ battery_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3239,7 +3239,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold2_at + } + + +- uint8_t battery_voltage_threshold2 = {}; ++ int8_t battery_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -3252,7 +3252,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold2_at + return; + } + // Start parsing value +- battery_voltage_threshold2 = json_payload.at("value").get(); ++ battery_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3315,7 +3315,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold3_at + } + + +- uint8_t battery_voltage_threshold3 = {}; ++ int8_t battery_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -3328,7 +3328,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold3_at + return; + } + // Start parsing value +- battery_voltage_threshold3 = json_payload.at("value").get(); ++ battery_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3391,7 +3391,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_min_thresh + } + + +- uint8_t battery_percentage_min_threshold = {}; ++ int8_t battery_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -3404,7 +3404,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_min_thresh + return; + } + // Start parsing value +- battery_percentage_min_threshold = json_payload.at("value").get(); ++ battery_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -3467,7 +3467,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold1 + } + + +- uint8_t battery_percentage_threshold1 = {}; ++ int8_t battery_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -3480,7 +3480,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold1 + return; + } + // Start parsing value +- battery_percentage_threshold1 = json_payload.at("value").get(); ++ battery_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3543,7 +3543,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold2 + } + + +- uint8_t battery_percentage_threshold2 = {}; ++ int8_t battery_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -3556,7 +3556,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold2 + return; + } + // Start parsing value +- battery_percentage_threshold2 = json_payload.at("value").get(); ++ battery_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3619,7 +3619,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold3 + } + + +- uint8_t battery_percentage_threshold3 = {}; ++ int8_t battery_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -3632,7 +3632,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold3 + return; + } + // Start parsing value +- battery_percentage_threshold3 = json_payload.at("value").get(); ++ battery_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3771,7 +3771,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_attribute_up + } + + +- uint8_t battery2_voltage = {}; ++ int8_t battery2_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -3784,7 +3784,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_attribute_up + return; + } + // Start parsing value +- battery2_voltage = json_payload.at("value").get(); ++ battery2_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -3847,7 +3847,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_remaining + } + + +- uint8_t battery2_percentage_remaining = {}; ++ int8_t battery2_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -3860,7 +3860,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_remaining + return; + } + // Start parsing value +- battery2_percentage_remaining = json_payload.at("value").get(); ++ battery2_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -4083,7 +4083,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2a_hr_rating_attribute + } + + +- uint16_t battery2a_hr_rating = {}; ++ int16_t battery2a_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -4096,7 +4096,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2a_hr_rating_attribute + return; + } + // Start parsing value +- battery2a_hr_rating = json_payload.at("value").get(); ++ battery2a_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -4159,7 +4159,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_quantity_attribute_u + } + + +- uint8_t battery2_quantity = {}; ++ int8_t battery2_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -4172,7 +4172,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_quantity_attribute_u + return; + } + // Start parsing value +- battery2_quantity = json_payload.at("value").get(); ++ battery2_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -4235,7 +4235,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_rated_voltage_attrib + } + + +- uint8_t battery2_rated_voltage = {}; ++ int8_t battery2_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -4248,7 +4248,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_rated_voltage_attrib + return; + } + // Start parsing value +- battery2_rated_voltage = json_payload.at("value").get(); ++ battery2_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -4387,7 +4387,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_min_threshol + } + + +- uint8_t battery2_voltage_min_threshold = {}; ++ int8_t battery2_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -4400,7 +4400,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_min_threshol + return; + } + // Start parsing value +- battery2_voltage_min_threshold = json_payload.at("value").get(); ++ battery2_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -4463,7 +4463,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold1_a + } + + +- uint8_t battery2_voltage_threshold1 = {}; ++ int8_t battery2_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -4476,7 +4476,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold1_a + return; + } + // Start parsing value +- battery2_voltage_threshold1 = json_payload.at("value").get(); ++ battery2_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4539,7 +4539,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold2_a + } + + +- uint8_t battery2_voltage_threshold2 = {}; ++ int8_t battery2_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -4552,7 +4552,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold2_a + return; + } + // Start parsing value +- battery2_voltage_threshold2 = json_payload.at("value").get(); ++ battery2_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4615,7 +4615,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold3_a + } + + +- uint8_t battery2_voltage_threshold3 = {}; ++ int8_t battery2_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -4628,7 +4628,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold3_a + return; + } + // Start parsing value +- battery2_voltage_threshold3 = json_payload.at("value").get(); ++ battery2_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4691,7 +4691,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_min_thres + } + + +- uint8_t battery2_percentage_min_threshold = {}; ++ int8_t battery2_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -4704,7 +4704,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_min_thres + return; + } + // Start parsing value +- battery2_percentage_min_threshold = json_payload.at("value").get(); ++ battery2_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -4767,7 +4767,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- uint8_t battery2_percentage_threshold1 = {}; ++ int8_t battery2_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -4780,7 +4780,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold1 = json_payload.at("value").get(); ++ battery2_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4843,7 +4843,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- uint8_t battery2_percentage_threshold2 = {}; ++ int8_t battery2_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -4856,7 +4856,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold2 = json_payload.at("value").get(); ++ battery2_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4919,7 +4919,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- uint8_t battery2_percentage_threshold3 = {}; ++ int8_t battery2_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -4932,7 +4932,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold3 = json_payload.at("value").get(); ++ battery2_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5071,7 +5071,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_attribute_up + } + + +- uint8_t battery3_voltage = {}; ++ int8_t battery3_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -5084,7 +5084,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_attribute_up + return; + } + // Start parsing value +- battery3_voltage = json_payload.at("value").get(); ++ battery3_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -5147,7 +5147,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_remaining + } + + +- uint8_t battery3_percentage_remaining = {}; ++ int8_t battery3_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -5160,7 +5160,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_remaining + return; + } + // Start parsing value +- battery3_percentage_remaining = json_payload.at("value").get(); ++ battery3_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -5383,7 +5383,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3a_hr_rating_attribute + } + + +- uint16_t battery3a_hr_rating = {}; ++ int16_t battery3a_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -5396,7 +5396,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3a_hr_rating_attribute + return; + } + // Start parsing value +- battery3a_hr_rating = json_payload.at("value").get(); ++ battery3a_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -5459,7 +5459,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_quantity_attribute_u + } + + +- uint8_t battery3_quantity = {}; ++ int8_t battery3_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -5472,7 +5472,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_quantity_attribute_u + return; + } + // Start parsing value +- battery3_quantity = json_payload.at("value").get(); ++ battery3_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -5535,7 +5535,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_rated_voltage_attrib + } + + +- uint8_t battery3_rated_voltage = {}; ++ int8_t battery3_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -5548,7 +5548,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_rated_voltage_attrib + return; + } + // Start parsing value +- battery3_rated_voltage = json_payload.at("value").get(); ++ battery3_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -5687,7 +5687,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_min_threshol + } + + +- uint8_t battery3_voltage_min_threshold = {}; ++ int8_t battery3_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -5700,7 +5700,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_min_threshol + return; + } + // Start parsing value +- battery3_voltage_min_threshold = json_payload.at("value").get(); ++ battery3_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -5763,7 +5763,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold1_a + } + + +- uint8_t battery3_voltage_threshold1 = {}; ++ int8_t battery3_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -5776,7 +5776,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold1_a + return; + } + // Start parsing value +- battery3_voltage_threshold1 = json_payload.at("value").get(); ++ battery3_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5839,7 +5839,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold2_a + } + + +- uint8_t battery3_voltage_threshold2 = {}; ++ int8_t battery3_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -5852,7 +5852,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold2_a + return; + } + // Start parsing value +- battery3_voltage_threshold2 = json_payload.at("value").get(); ++ battery3_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5915,7 +5915,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold3_a + } + + +- uint8_t battery3_voltage_threshold3 = {}; ++ int8_t battery3_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -5928,7 +5928,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold3_a + return; + } + // Start parsing value +- battery3_voltage_threshold3 = json_payload.at("value").get(); ++ battery3_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5991,7 +5991,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_min_thres + } + + +- uint8_t battery3_percentage_min_threshold = {}; ++ int8_t battery3_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -6004,7 +6004,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_min_thres + return; + } + // Start parsing value +- battery3_percentage_min_threshold = json_payload.at("value").get(); ++ battery3_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -6067,7 +6067,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- uint8_t battery3_percentage_threshold1 = {}; ++ int8_t battery3_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -6080,7 +6080,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold1 = json_payload.at("value").get(); ++ battery3_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -6143,7 +6143,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- uint8_t battery3_percentage_threshold2 = {}; ++ int8_t battery3_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -6156,7 +6156,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold2 = json_payload.at("value").get(); ++ battery3_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -6219,7 +6219,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- uint8_t battery3_percentage_threshold3 = {}; ++ int8_t battery3_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -6232,7 +6232,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold3 = json_payload.at("value").get(); ++ battery3_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -7091,7 +7091,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_over_temp_total_ + } + + +- uint16_t over_temp_total_dwell = {}; ++ int16_t over_temp_total_dwell = {}; + + nlohmann::json json_payload; + try { +@@ -7104,7 +7104,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_over_temp_total_ + return; + } + // Start parsing value +- over_temp_total_dwell = json_payload.at("value").get(); ++ over_temp_total_dwell = json_payload.at("value").get(); + + // End parsing value + } +@@ -7395,7 +7395,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_low_temp_dwell_t + } + + +- uint32_t low_temp_dwell_trip_point = {}; ++ int32_t low_temp_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -7408,7 +7408,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_low_temp_dwell_t + return; + } + // Start parsing value +- low_temp_dwell_trip_point = json_payload.at("value").get(); ++ low_temp_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -7471,7 +7471,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_high_temp_dwell_ + } + + +- uint32_t high_temp_dwell_trip_point = {}; ++ int32_t high_temp_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -7484,7 +7484,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_high_temp_dwell_ + return; + } + // Start parsing value +- high_temp_dwell_trip_point = json_payload.at("value").get(); ++ high_temp_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -7647,7 +7647,7 @@ static void uic_mqtt_dotdot_on_identify_identify_time_attribute_update( + } + + +- uint16_t identify_time = {}; ++ int16_t identify_time = {}; + + nlohmann::json json_payload; + try { +@@ -7660,7 +7660,7 @@ static void uic_mqtt_dotdot_on_identify_identify_time_attribute_update( + return; + } + // Start parsing value +- identify_time = json_payload.at("value").get(); ++ identify_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -7877,7 +7877,7 @@ static void uic_mqtt_dotdot_on_scenes_scene_count_attribute_update( + } + + +- uint8_t scene_count = {}; ++ int8_t scene_count = {}; + + nlohmann::json json_payload; + try { +@@ -7890,7 +7890,7 @@ static void uic_mqtt_dotdot_on_scenes_scene_count_attribute_update( + return; + } + // Start parsing value +- scene_count = json_payload.at("value").get(); ++ scene_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -7953,7 +7953,7 @@ static void uic_mqtt_dotdot_on_scenes_current_scene_attribute_update( + } + + +- uint8_t current_scene = {}; ++ int8_t current_scene = {}; + + nlohmann::json json_payload; + try { +@@ -7966,7 +7966,7 @@ static void uic_mqtt_dotdot_on_scenes_current_scene_attribute_update( + return; + } + // Start parsing value +- current_scene = json_payload.at("value").get(); ++ current_scene = json_payload.at("value").get(); + + // End parsing value + } +@@ -8029,7 +8029,7 @@ static void uic_mqtt_dotdot_on_scenes_current_group_attribute_update( + } + + +- uint16_t current_group = {}; ++ uint8_t * current_group = {}; + + nlohmann::json json_payload; + try { +@@ -8042,7 +8042,7 @@ static void uic_mqtt_dotdot_on_scenes_current_group_attribute_update( + return; + } + // Start parsing value +- current_group = json_payload.at("value").get(); ++ current_group = json_payload.at("value").get(); + + // End parsing value + } +@@ -8350,11 +8350,11 @@ static void uic_mqtt_dotdot_on_scenes_scene_table_attribute_update( + auto &scene_table_json = json_payload.at("value"); + for (size_t i = 0; i < scene_table_json.size(); i++) { + SSceneTable element = {}; +- element.SceneID = scene_table_json.at(i).at("SceneID").get(); +- element.GroupID = scene_table_json.at(i).at("GroupID").get(); ++ element.SceneID = scene_table_json.at(i).at("SceneID").get(); ++ element.GroupID = scene_table_json.at(i).at("GroupID").get(); + element.SceneName = scene_table_json.at(i).at("SceneName").get_ptr()->c_str(); +- element.TransitionTime = scene_table_json.at(i).at("TransitionTime").get(); +- element.TransitionTime100ms = scene_table_json.at(i).at("TransitionTime100ms").get(); ++ element.TransitionTime = scene_table_json.at(i).at("TransitionTime").get(); ++ element.TransitionTime100ms = scene_table_json.at(i).at("TransitionTime100ms").get(); + element.SceneTableExtensions = scene_table_json.at(i).at("SceneTableExtensions").get_ptr()->c_str(); + scene_table.push_back(element); + } +@@ -8663,7 +8663,7 @@ static void uic_mqtt_dotdot_on_on_off_on_time_attribute_update( + } + + +- uint16_t on_time = {}; ++ int16_t on_time = {}; + + nlohmann::json json_payload; + try { +@@ -8676,7 +8676,7 @@ static void uic_mqtt_dotdot_on_on_off_on_time_attribute_update( + return; + } + // Start parsing value +- on_time = json_payload.at("value").get(); ++ on_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -8739,7 +8739,7 @@ static void uic_mqtt_dotdot_on_on_off_off_wait_time_attribute_update( + } + + +- uint16_t off_wait_time = {}; ++ int16_t off_wait_time = {}; + + nlohmann::json json_payload; + try { +@@ -8752,7 +8752,7 @@ static void uic_mqtt_dotdot_on_on_off_off_wait_time_attribute_update( + return; + } + // Start parsing value +- off_wait_time = json_payload.at("value").get(); ++ off_wait_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -8980,7 +8980,7 @@ static void uic_mqtt_dotdot_on_level_current_level_attribute_update( + } + + +- uint8_t current_level = {}; ++ int8_t current_level = {}; + + nlohmann::json json_payload; + try { +@@ -8993,7 +8993,7 @@ static void uic_mqtt_dotdot_on_level_current_level_attribute_update( + return; + } + // Start parsing value +- current_level = json_payload.at("value").get(); ++ current_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9056,7 +9056,7 @@ static void uic_mqtt_dotdot_on_level_remaining_time_attribute_update( + } + + +- uint16_t remaining_time = {}; ++ int16_t remaining_time = {}; + + nlohmann::json json_payload; + try { +@@ -9069,7 +9069,7 @@ static void uic_mqtt_dotdot_on_level_remaining_time_attribute_update( + return; + } + // Start parsing value +- remaining_time = json_payload.at("value").get(); ++ remaining_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9132,7 +9132,7 @@ static void uic_mqtt_dotdot_on_level_min_level_attribute_update( + } + + +- uint8_t min_level = {}; ++ int8_t min_level = {}; + + nlohmann::json json_payload; + try { +@@ -9145,7 +9145,7 @@ static void uic_mqtt_dotdot_on_level_min_level_attribute_update( + return; + } + // Start parsing value +- min_level = json_payload.at("value").get(); ++ min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9208,7 +9208,7 @@ static void uic_mqtt_dotdot_on_level_max_level_attribute_update( + } + + +- uint8_t max_level = {}; ++ int8_t max_level = {}; + + nlohmann::json json_payload; + try { +@@ -9221,7 +9221,7 @@ static void uic_mqtt_dotdot_on_level_max_level_attribute_update( + return; + } + // Start parsing value +- max_level = json_payload.at("value").get(); ++ max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9284,7 +9284,7 @@ static void uic_mqtt_dotdot_on_level_current_frequency_attribute_update( + } + + +- uint16_t current_frequency = {}; ++ int16_t current_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9297,7 +9297,7 @@ static void uic_mqtt_dotdot_on_level_current_frequency_attribute_update( + return; + } + // Start parsing value +- current_frequency = json_payload.at("value").get(); ++ current_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9360,7 +9360,7 @@ static void uic_mqtt_dotdot_on_level_min_frequency_attribute_update( + } + + +- uint16_t min_frequency = {}; ++ int16_t min_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9373,7 +9373,7 @@ static void uic_mqtt_dotdot_on_level_min_frequency_attribute_update( + return; + } + // Start parsing value +- min_frequency = json_payload.at("value").get(); ++ min_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9436,7 +9436,7 @@ static void uic_mqtt_dotdot_on_level_max_frequency_attribute_update( + } + + +- uint16_t max_frequency = {}; ++ int16_t max_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9449,7 +9449,7 @@ static void uic_mqtt_dotdot_on_level_max_frequency_attribute_update( + return; + } + // Start parsing value +- max_frequency = json_payload.at("value").get(); ++ max_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9588,7 +9588,7 @@ static void uic_mqtt_dotdot_on_level_on_off_transition_time_attribute_update( + } + + +- uint16_t on_off_transition_time = {}; ++ int16_t on_off_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9601,7 +9601,7 @@ static void uic_mqtt_dotdot_on_level_on_off_transition_time_attribute_update( + return; + } + // Start parsing value +- on_off_transition_time = json_payload.at("value").get(); ++ on_off_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9664,7 +9664,7 @@ static void uic_mqtt_dotdot_on_level_on_level_attribute_update( + } + + +- uint8_t on_level = {}; ++ int8_t on_level = {}; + + nlohmann::json json_payload; + try { +@@ -9677,7 +9677,7 @@ static void uic_mqtt_dotdot_on_level_on_level_attribute_update( + return; + } + // Start parsing value +- on_level = json_payload.at("value").get(); ++ on_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9740,7 +9740,7 @@ static void uic_mqtt_dotdot_on_level_on_transition_time_attribute_update( + } + + +- uint16_t on_transition_time = {}; ++ int16_t on_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9753,7 +9753,7 @@ static void uic_mqtt_dotdot_on_level_on_transition_time_attribute_update( + return; + } + // Start parsing value +- on_transition_time = json_payload.at("value").get(); ++ on_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9816,7 +9816,7 @@ static void uic_mqtt_dotdot_on_level_off_transition_time_attribute_update( + } + + +- uint16_t off_transition_time = {}; ++ int16_t off_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9829,7 +9829,7 @@ static void uic_mqtt_dotdot_on_level_off_transition_time_attribute_update( + return; + } + // Start parsing value +- off_transition_time = json_payload.at("value").get(); ++ off_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9892,7 +9892,7 @@ static void uic_mqtt_dotdot_on_level_default_move_rate_attribute_update( + } + + +- uint16_t default_move_rate = {}; ++ int16_t default_move_rate = {}; + + nlohmann::json json_payload; + try { +@@ -9905,7 +9905,7 @@ static void uic_mqtt_dotdot_on_level_default_move_rate_attribute_update( + return; + } + // Start parsing value +- default_move_rate = json_payload.at("value").get(); ++ default_move_rate = json_payload.at("value").get(); + + // End parsing value + } +@@ -9968,7 +9968,7 @@ static void uic_mqtt_dotdot_on_level_start_up_current_level_attribute_update( + } + + +- uint8_t start_up_current_level = {}; ++ int8_t start_up_current_level = {}; + + nlohmann::json json_payload; + try { +@@ -9981,7 +9981,7 @@ static void uic_mqtt_dotdot_on_level_start_up_current_level_attribute_update( + return; + } + // Start parsing value +- start_up_current_level = json_payload.at("value").get(); ++ start_up_current_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -10184,7 +10184,7 @@ static void uic_mqtt_dotdot_on_alarms_alarm_count_attribute_update( + } + + +- uint16_t alarm_count = {}; ++ int16_t alarm_count = {}; + + nlohmann::json json_payload; + try { +@@ -10197,7 +10197,7 @@ static void uic_mqtt_dotdot_on_alarms_alarm_count_attribute_update( + return; + } + // Start parsing value +- alarm_count = json_payload.at("value").get(); ++ alarm_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -10305,7 +10305,7 @@ static void uic_mqtt_dotdot_on_time_time_attribute_update( + } + + +- uint32_t time = {}; ++ uint8_t time = {}; + + nlohmann::json json_payload; + try { +@@ -10318,7 +10318,7 @@ static void uic_mqtt_dotdot_on_time_time_attribute_update( + return; + } + // Start parsing value +- time = json_payload.at("value").get(); ++ time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10533,7 +10533,7 @@ static void uic_mqtt_dotdot_on_time_dst_start_attribute_update( + } + + +- uint32_t dst_start = {}; ++ int32_t dst_start = {}; + + nlohmann::json json_payload; + try { +@@ -10546,7 +10546,7 @@ static void uic_mqtt_dotdot_on_time_dst_start_attribute_update( + return; + } + // Start parsing value +- dst_start = json_payload.at("value").get(); ++ dst_start = json_payload.at("value").get(); + + // End parsing value + } +@@ -10609,7 +10609,7 @@ static void uic_mqtt_dotdot_on_time_dst_end_attribute_update( + } + + +- uint32_t dst_end = {}; ++ int32_t dst_end = {}; + + nlohmann::json json_payload; + try { +@@ -10622,7 +10622,7 @@ static void uic_mqtt_dotdot_on_time_dst_end_attribute_update( + return; + } + // Start parsing value +- dst_end = json_payload.at("value").get(); ++ dst_end = json_payload.at("value").get(); + + // End parsing value + } +@@ -10761,7 +10761,7 @@ static void uic_mqtt_dotdot_on_time_standard_time_attribute_update( + } + + +- uint32_t standard_time = {}; ++ int32_t standard_time = {}; + + nlohmann::json json_payload; + try { +@@ -10774,7 +10774,7 @@ static void uic_mqtt_dotdot_on_time_standard_time_attribute_update( + return; + } + // Start parsing value +- standard_time = json_payload.at("value").get(); ++ standard_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10837,7 +10837,7 @@ static void uic_mqtt_dotdot_on_time_local_time_attribute_update( + } + + +- uint32_t local_time = {}; ++ int32_t local_time = {}; + + nlohmann::json json_payload; + try { +@@ -10850,7 +10850,7 @@ static void uic_mqtt_dotdot_on_time_local_time_attribute_update( + return; + } + // Start parsing value +- local_time = json_payload.at("value").get(); ++ local_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10913,7 +10913,7 @@ static void uic_mqtt_dotdot_on_time_last_set_time_attribute_update( + } + + +- uint32_t last_set_time = {}; ++ uint8_t last_set_time = {}; + + nlohmann::json json_payload; + try { +@@ -10926,7 +10926,7 @@ static void uic_mqtt_dotdot_on_time_last_set_time_attribute_update( + return; + } + // Start parsing value +- last_set_time = json_payload.at("value").get(); ++ last_set_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10989,7 +10989,7 @@ static void uic_mqtt_dotdot_on_time_valid_until_time_attribute_update( + } + + +- uint32_t valid_until_time = {}; ++ uint8_t valid_until_time = {}; + + nlohmann::json json_payload; + try { +@@ -11002,7 +11002,7 @@ static void uic_mqtt_dotdot_on_time_valid_until_time_attribute_update( + return; + } + // Start parsing value +- valid_until_time = json_payload.at("value").get(); ++ valid_until_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -11179,7 +11179,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_attribute_update( + } + + +- uint32_t check_in_interval = {}; ++ int32_t check_in_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11192,7 +11192,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_attribute_update( + return; + } + // Start parsing value +- check_in_interval = json_payload.at("value").get(); ++ check_in_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11255,7 +11255,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_attribute_update( + } + + +- uint32_t long_poll_interval = {}; ++ int32_t long_poll_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11268,7 +11268,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_attribute_update( + return; + } + // Start parsing value +- long_poll_interval = json_payload.at("value").get(); ++ long_poll_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11331,7 +11331,7 @@ static void uic_mqtt_dotdot_on_poll_control_short_poll_interval_attribute_update + } + + +- uint16_t short_poll_interval = {}; ++ int16_t short_poll_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11344,7 +11344,7 @@ static void uic_mqtt_dotdot_on_poll_control_short_poll_interval_attribute_update + return; + } + // Start parsing value +- short_poll_interval = json_payload.at("value").get(); ++ short_poll_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11407,7 +11407,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_attribute_update( + } + + +- uint16_t fast_poll_timeout = {}; ++ int16_t fast_poll_timeout = {}; + + nlohmann::json json_payload; + try { +@@ -11420,7 +11420,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_attribute_update( + return; + } + // Start parsing value +- fast_poll_timeout = json_payload.at("value").get(); ++ fast_poll_timeout = json_payload.at("value").get(); + + // End parsing value + } +@@ -11483,7 +11483,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_min_attribute_upda + } + + +- uint32_t check_in_interval_min = {}; ++ int32_t check_in_interval_min = {}; + + nlohmann::json json_payload; + try { +@@ -11496,7 +11496,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_min_attribute_upda + return; + } + // Start parsing value +- check_in_interval_min = json_payload.at("value").get(); ++ check_in_interval_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -11559,7 +11559,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_min_attribute_upd + } + + +- uint32_t long_poll_interval_min = {}; ++ int32_t long_poll_interval_min = {}; + + nlohmann::json json_payload; + try { +@@ -11572,7 +11572,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_min_attribute_upd + return; + } + // Start parsing value +- long_poll_interval_min = json_payload.at("value").get(); ++ long_poll_interval_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -11635,7 +11635,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_max_attribute_upda + } + + +- uint16_t fast_poll_timeout_max = {}; ++ int16_t fast_poll_timeout_max = {}; + + nlohmann::json json_payload; + try { +@@ -11648,7 +11648,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_max_attribute_upda + return; + } + // Start parsing value +- fast_poll_timeout_max = json_payload.at("value").get(); ++ fast_poll_timeout_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -11799,7 +11799,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_physical_closed_limit_attribu + } + + +- uint16_t physical_closed_limit = {}; ++ int16_t physical_closed_limit = {}; + + nlohmann::json json_payload; + try { +@@ -11812,7 +11812,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_physical_closed_limit_attribu + return; + } + // Start parsing value +- physical_closed_limit = json_payload.at("value").get(); ++ physical_closed_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -11875,7 +11875,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_motor_step_size_attribute_upd + } + + +- uint8_t motor_step_size = {}; ++ int8_t motor_step_size = {}; + + nlohmann::json json_payload; + try { +@@ -11888,7 +11888,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_motor_step_size_attribute_upd + return; + } + // Start parsing value +- motor_step_size = json_payload.at("value").get(); ++ motor_step_size = json_payload.at("value").get(); + + // End parsing value + } +@@ -12027,7 +12027,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_closed_limit_attribute_update + } + + +- uint16_t closed_limit = {}; ++ int16_t closed_limit = {}; + + nlohmann::json json_payload; + try { +@@ -12040,7 +12040,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_closed_limit_attribute_update + return; + } + // Start parsing value +- closed_limit = json_payload.at("value").get(); ++ closed_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -12630,7 +12630,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_open_events_attribute_update( + } + + +- uint32_t door_open_events = {}; ++ int32_t door_open_events = {}; + + nlohmann::json json_payload; + try { +@@ -12643,7 +12643,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_open_events_attribute_update( + return; + } + // Start parsing value +- door_open_events = json_payload.at("value").get(); ++ door_open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -12706,7 +12706,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_closed_events_attribute_update( + } + + +- uint32_t door_closed_events = {}; ++ int32_t door_closed_events = {}; + + nlohmann::json json_payload; + try { +@@ -12719,7 +12719,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_closed_events_attribute_update( + return; + } + // Start parsing value +- door_closed_events = json_payload.at("value").get(); ++ door_closed_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -12782,7 +12782,7 @@ static void uic_mqtt_dotdot_on_door_lock_open_period_attribute_update( + } + + +- uint16_t open_period = {}; ++ int16_t open_period = {}; + + nlohmann::json json_payload; + try { +@@ -12795,7 +12795,7 @@ static void uic_mqtt_dotdot_on_door_lock_open_period_attribute_update( + return; + } + // Start parsing value +- open_period = json_payload.at("value").get(); ++ open_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -12858,7 +12858,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_log_records_supported_attribu + } + + +- uint16_t number_of_log_records_supported = {}; ++ int16_t number_of_log_records_supported = {}; + + nlohmann::json json_payload; + try { +@@ -12871,7 +12871,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_log_records_supported_attribu + return; + } + // Start parsing value +- number_of_log_records_supported = json_payload.at("value").get(); ++ number_of_log_records_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -12934,7 +12934,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_total_users_supported_attribu + } + + +- uint16_t number_of_total_users_supported = {}; ++ int16_t number_of_total_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -12947,7 +12947,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_total_users_supported_attribu + return; + } + // Start parsing value +- number_of_total_users_supported = json_payload.at("value").get(); ++ number_of_total_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13010,7 +13010,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_pin_users_supported_attribute + } + + +- uint16_t number_of_pin_users_supported = {}; ++ int16_t number_of_pin_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13023,7 +13023,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_pin_users_supported_attribute + return; + } + // Start parsing value +- number_of_pin_users_supported = json_payload.at("value").get(); ++ number_of_pin_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13086,7 +13086,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_rfid_users_supported_attribut + } + + +- uint16_t number_of_rfid_users_supported = {}; ++ int16_t number_of_rfid_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13099,7 +13099,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_rfid_users_supported_attribut + return; + } + // Start parsing value +- number_of_rfid_users_supported = json_payload.at("value").get(); ++ number_of_rfid_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13162,7 +13162,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_week_day_schedules_supported_ + } + + +- uint8_t number_of_week_day_schedules_supported_per_user = {}; ++ int8_t number_of_week_day_schedules_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13175,7 +13175,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_week_day_schedules_supported_ + return; + } + // Start parsing value +- number_of_week_day_schedules_supported_per_user = json_payload.at("value").get(); ++ number_of_week_day_schedules_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13238,7 +13238,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_year_day_schedules_supported_ + } + + +- uint8_t number_of_year_day_schedules_supported_per_user = {}; ++ int8_t number_of_year_day_schedules_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13251,7 +13251,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_year_day_schedules_supported_ + return; + } + // Start parsing value +- number_of_year_day_schedules_supported_per_user = json_payload.at("value").get(); ++ number_of_year_day_schedules_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13314,7 +13314,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_holiday_schedules_supported_a + } + + +- uint8_t number_of_holiday_schedules_supported = {}; ++ int8_t number_of_holiday_schedules_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13327,7 +13327,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_holiday_schedules_supported_a + return; + } + // Start parsing value +- number_of_holiday_schedules_supported = json_payload.at("value").get(); ++ number_of_holiday_schedules_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13390,7 +13390,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_pin_code_length_attribute_update( + } + + +- uint8_t max_pin_code_length = {}; ++ int8_t max_pin_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13403,7 +13403,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_pin_code_length_attribute_update( + return; + } + // Start parsing value +- max_pin_code_length = json_payload.at("value").get(); ++ max_pin_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13466,7 +13466,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_pin_code_length_attribute_update( + } + + +- uint8_t min_pin_code_length = {}; ++ int8_t min_pin_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13479,7 +13479,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_pin_code_length_attribute_update( + return; + } + // Start parsing value +- min_pin_code_length = json_payload.at("value").get(); ++ min_pin_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13542,7 +13542,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_rfid_code_length_attribute_update( + } + + +- uint8_t max_rfid_code_length = {}; ++ int8_t max_rfid_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13555,7 +13555,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_rfid_code_length_attribute_update( + return; + } + // Start parsing value +- max_rfid_code_length = json_payload.at("value").get(); ++ max_rfid_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13618,7 +13618,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_rfid_code_length_attribute_update( + } + + +- uint8_t min_rfid_code_length = {}; ++ int8_t min_rfid_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13631,7 +13631,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_rfid_code_length_attribute_update( + return; + } + // Start parsing value +- min_rfid_code_length = json_payload.at("value").get(); ++ min_rfid_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13770,7 +13770,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_credentials_supported_per_use + } + + +- uint8_t number_of_credentials_supported_per_user = {}; ++ int8_t number_of_credentials_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13783,7 +13783,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_credentials_supported_per_use + return; + } + // Start parsing value +- number_of_credentials_supported_per_user = json_payload.at("value").get(); ++ number_of_credentials_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13998,7 +13998,7 @@ static void uic_mqtt_dotdot_on_door_lock_led_settings_attribute_update( + } + + +- uint8_t led_settings = {}; ++ int8_t led_settings = {}; + + nlohmann::json json_payload; + try { +@@ -14011,7 +14011,7 @@ static void uic_mqtt_dotdot_on_door_lock_led_settings_attribute_update( + return; + } + // Start parsing value +- led_settings = json_payload.at("value").get(); ++ led_settings = json_payload.at("value").get(); + + // End parsing value + } +@@ -14074,7 +14074,7 @@ static void uic_mqtt_dotdot_on_door_lock_auto_relock_time_attribute_update( + } + + +- uint32_t auto_relock_time = {}; ++ int32_t auto_relock_time = {}; + + nlohmann::json json_payload; + try { +@@ -14087,7 +14087,7 @@ static void uic_mqtt_dotdot_on_door_lock_auto_relock_time_attribute_update( + return; + } + // Start parsing value +- auto_relock_time = json_payload.at("value").get(); ++ auto_relock_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -14150,7 +14150,7 @@ static void uic_mqtt_dotdot_on_door_lock_sound_volume_attribute_update( + } + + +- uint8_t sound_volume = {}; ++ int8_t sound_volume = {}; + + nlohmann::json json_payload; + try { +@@ -14163,7 +14163,7 @@ static void uic_mqtt_dotdot_on_door_lock_sound_volume_attribute_update( + return; + } + // Start parsing value +- sound_volume = json_payload.at("value").get(); ++ sound_volume = json_payload.at("value").get(); + + // End parsing value + } +@@ -14842,7 +14842,7 @@ static void uic_mqtt_dotdot_on_door_lock_wrong_code_entry_limit_attribute_update + } + + +- uint8_t wrong_code_entry_limit = {}; ++ int8_t wrong_code_entry_limit = {}; + + nlohmann::json json_payload; + try { +@@ -14855,7 +14855,7 @@ static void uic_mqtt_dotdot_on_door_lock_wrong_code_entry_limit_attribute_update + return; + } + // Start parsing value +- wrong_code_entry_limit = json_payload.at("value").get(); ++ wrong_code_entry_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -14918,7 +14918,7 @@ static void uic_mqtt_dotdot_on_door_lock_user_code_temporary_disable_time_attrib + } + + +- uint8_t user_code_temporary_disable_time = {}; ++ int8_t user_code_temporary_disable_time = {}; + + nlohmann::json json_payload; + try { +@@ -14931,7 +14931,7 @@ static void uic_mqtt_dotdot_on_door_lock_user_code_temporary_disable_time_attrib + return; + } + // Start parsing value +- user_code_temporary_disable_time = json_payload.at("value").get(); ++ user_code_temporary_disable_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -15230,7 +15230,7 @@ static void uic_mqtt_dotdot_on_door_lock_expiring_user_timeout_attribute_update( + } + + +- uint16_t expiring_user_timeout = {}; ++ int16_t expiring_user_timeout = {}; + + nlohmann::json json_payload; + try { +@@ -15243,7 +15243,7 @@ static void uic_mqtt_dotdot_on_door_lock_expiring_user_timeout_attribute_update( + return; + } + // Start parsing value +- expiring_user_timeout = json_payload.at("value").get(); ++ expiring_user_timeout = json_payload.at("value").get(); + + // End parsing value + } +@@ -16505,7 +16505,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_lift_attrib + } + + +- uint16_t physical_closed_limit_lift = {}; ++ int16_t physical_closed_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16518,7 +16518,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_lift_attrib + return; + } + // Start parsing value +- physical_closed_limit_lift = json_payload.at("value").get(); ++ physical_closed_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16581,7 +16581,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_tilt_attrib + } + + +- uint16_t physical_closed_limit_tilt = {}; ++ int16_t physical_closed_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16594,7 +16594,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_tilt_attrib + return; + } + // Start parsing value +- physical_closed_limit_tilt = json_payload.at("value").get(); ++ physical_closed_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -16657,7 +16657,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_attribute_u + } + + +- uint16_t current_position_lift = {}; ++ int16_t current_position_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16670,7 +16670,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_attribute_u + return; + } + // Start parsing value +- current_position_lift = json_payload.at("value").get(); ++ current_position_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16733,7 +16733,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_attribute_u + } + + +- uint16_t current_position_tilt = {}; ++ int16_t current_position_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16746,7 +16746,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_attribute_u + return; + } + // Start parsing value +- current_position_tilt = json_payload.at("value").get(); ++ current_position_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -16809,7 +16809,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_lift_attribu + } + + +- uint16_t number_of_actuations_lift = {}; ++ int16_t number_of_actuations_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16822,7 +16822,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_lift_attribu + return; + } + // Start parsing value +- number_of_actuations_lift = json_payload.at("value").get(); ++ number_of_actuations_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16885,7 +16885,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_tilt_attribu + } + + +- uint16_t number_of_actuations_tilt = {}; ++ int16_t number_of_actuations_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16898,7 +16898,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_tilt_attribu + return; + } + // Start parsing value +- number_of_actuations_tilt = json_payload.at("value").get(); ++ number_of_actuations_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17037,7 +17037,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_percentage_ + } + + +- uint8_t current_position_lift_percentage = {}; ++ int8_t current_position_lift_percentage = {}; + + nlohmann::json json_payload; + try { +@@ -17050,7 +17050,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_percentage_ + return; + } + // Start parsing value +- current_position_lift_percentage = json_payload.at("value").get(); ++ current_position_lift_percentage = json_payload.at("value").get(); + + // End parsing value + } +@@ -17113,7 +17113,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_percentage_ + } + + +- uint8_t current_position_tilt_percentage = {}; ++ int8_t current_position_tilt_percentage = {}; + + nlohmann::json json_payload; + try { +@@ -17126,7 +17126,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_percentage_ + return; + } + // Start parsing value +- current_position_tilt_percentage = json_payload.at("value").get(); ++ current_position_tilt_percentage = json_payload.at("value").get(); + + // End parsing value + } +@@ -17189,7 +17189,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_lift_attribu + } + + +- uint16_t installed_open_limit_lift = {}; ++ int16_t installed_open_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17202,7 +17202,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_lift_attribu + return; + } + // Start parsing value +- installed_open_limit_lift = json_payload.at("value").get(); ++ installed_open_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17265,7 +17265,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_lift_attri + } + + +- uint16_t installed_closed_limit_lift = {}; ++ int16_t installed_closed_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17278,7 +17278,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_lift_attri + return; + } + // Start parsing value +- installed_closed_limit_lift = json_payload.at("value").get(); ++ installed_closed_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17341,7 +17341,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_tilt_attribu + } + + +- uint16_t installed_open_limit_tilt = {}; ++ int16_t installed_open_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -17354,7 +17354,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_tilt_attribu + return; + } + // Start parsing value +- installed_open_limit_tilt = json_payload.at("value").get(); ++ installed_open_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17417,7 +17417,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_tilt_attri + } + + +- uint16_t installed_closed_limit_tilt = {}; ++ int16_t installed_closed_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -17430,7 +17430,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_tilt_attri + return; + } + // Start parsing value +- installed_closed_limit_tilt = json_payload.at("value").get(); ++ installed_closed_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17493,7 +17493,7 @@ static void uic_mqtt_dotdot_on_window_covering_velocity_lift_attribute_update( + } + + +- uint16_t velocity_lift = {}; ++ int16_t velocity_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17506,7 +17506,7 @@ static void uic_mqtt_dotdot_on_window_covering_velocity_lift_attribute_update( + return; + } + // Start parsing value +- velocity_lift = json_payload.at("value").get(); ++ velocity_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17569,7 +17569,7 @@ static void uic_mqtt_dotdot_on_window_covering_acceleration_time_lift_attribute_ + } + + +- uint16_t acceleration_time_lift = {}; ++ int16_t acceleration_time_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17582,7 +17582,7 @@ static void uic_mqtt_dotdot_on_window_covering_acceleration_time_lift_attribute_ + return; + } + // Start parsing value +- acceleration_time_lift = json_payload.at("value").get(); ++ acceleration_time_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17645,7 +17645,7 @@ static void uic_mqtt_dotdot_on_window_covering_deceleration_time_lift_attribute_ + } + + +- uint16_t deceleration_time_lift = {}; ++ int16_t deceleration_time_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17658,7 +17658,7 @@ static void uic_mqtt_dotdot_on_window_covering_deceleration_time_lift_attribute_ + return; + } + // Start parsing value +- deceleration_time_lift = json_payload.at("value").get(); ++ deceleration_time_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17797,7 +17797,7 @@ static void uic_mqtt_dotdot_on_window_covering_intermediate_setpoints_lift_attri + } + + +- const char* intermediate_setpoints_lift = {}; ++ uint8_t intermediate_setpoints_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17873,7 +17873,7 @@ static void uic_mqtt_dotdot_on_window_covering_intermediate_setpoints_tilt_attri + } + + +- const char* intermediate_setpoints_tilt = {}; ++ uint8_t intermediate_setpoints_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -18382,7 +18382,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_events_attribute_update( + } + + +- uint16_t open_events = {}; ++ int16_t open_events = {}; + + nlohmann::json json_payload; + try { +@@ -18395,7 +18395,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_events_attribute_update( + return; + } + // Start parsing value +- open_events = json_payload.at("value").get(); ++ open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18458,7 +18458,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_events_attribute_update( + } + + +- uint16_t close_events = {}; ++ int16_t close_events = {}; + + nlohmann::json json_payload; + try { +@@ -18471,7 +18471,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_events_attribute_update( + return; + } + // Start parsing value +- close_events = json_payload.at("value").get(); ++ close_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18534,7 +18534,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_open_events_attribute_upd + } + + +- uint16_t command_open_events = {}; ++ int16_t command_open_events = {}; + + nlohmann::json json_payload; + try { +@@ -18547,7 +18547,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_open_events_attribute_upd + return; + } + // Start parsing value +- command_open_events = json_payload.at("value").get(); ++ command_open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18610,7 +18610,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_close_events_attribute_up + } + + +- uint16_t command_close_events = {}; ++ int16_t command_close_events = {}; + + nlohmann::json json_payload; + try { +@@ -18623,7 +18623,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_close_events_attribute_up + return; + } + // Start parsing value +- command_close_events = json_payload.at("value").get(); ++ command_close_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18686,7 +18686,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_period_attribute_update( + } + + +- uint16_t open_period = {}; ++ int16_t open_period = {}; + + nlohmann::json json_payload; + try { +@@ -18699,7 +18699,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_period_attribute_update( + return; + } + // Start parsing value +- open_period = json_payload.at("value").get(); ++ open_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -18762,7 +18762,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_period_attribute_update( + } + + +- uint16_t close_period = {}; ++ int16_t close_period = {}; + + nlohmann::json json_payload; + try { +@@ -18775,7 +18775,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_period_attribute_update( + return; + } + // Start parsing value +- close_period = json_payload.at("value").get(); ++ close_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -18838,7 +18838,7 @@ static void uic_mqtt_dotdot_on_barrier_control_barrier_position_attribute_update + } + + +- uint8_t barrier_position = {}; ++ int8_t barrier_position = {}; + + nlohmann::json json_payload; + try { +@@ -18851,7 +18851,7 @@ static void uic_mqtt_dotdot_on_barrier_control_barrier_position_attribute_update + return; + } + // Start parsing value +- barrier_position = json_payload.at("value").get(); ++ barrier_position = json_payload.at("value").get(); + + // End parsing value + } +@@ -19121,7 +19121,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_speed_attribut + } + + +- uint16_t max_speed = {}; ++ int16_t max_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19134,7 +19134,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_speed_attribut + return; + } + // Start parsing value +- max_speed = json_payload.at("value").get(); ++ max_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19197,7 +19197,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_flow_attribute + } + + +- uint16_t max_flow = {}; ++ int16_t max_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19210,7 +19210,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_flow_attribute + return; + } + // Start parsing value +- max_flow = json_payload.at("value").get(); ++ max_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -19577,7 +19577,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_speed_at + } + + +- uint16_t min_const_speed = {}; ++ int16_t min_const_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19590,7 +19590,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_speed_at + return; + } + // Start parsing value +- min_const_speed = json_payload.at("value").get(); ++ min_const_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19653,7 +19653,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_speed_at + } + + +- uint16_t max_const_speed = {}; ++ int16_t max_const_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19666,7 +19666,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_speed_at + return; + } + // Start parsing value +- max_const_speed = json_payload.at("value").get(); ++ max_const_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19729,7 +19729,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_flow_att + } + + +- uint16_t min_const_flow = {}; ++ int16_t min_const_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19742,7 +19742,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_flow_att + return; + } + // Start parsing value +- min_const_flow = json_payload.at("value").get(); ++ min_const_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -19805,7 +19805,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_flow_att + } + + +- uint16_t max_const_flow = {}; ++ int16_t max_const_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19818,7 +19818,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_flow_att + return; + } + // Start parsing value +- max_const_flow = json_payload.at("value").get(); ++ max_const_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -20353,7 +20353,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_speed_attribute_up + } + + +- uint16_t speed = {}; ++ int16_t speed = {}; + + nlohmann::json json_payload; + try { +@@ -20366,7 +20366,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_speed_attribute_up + return; + } + // Start parsing value +- speed = json_payload.at("value").get(); ++ speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -20429,7 +20429,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_running_h + } + + +- uint32_t lifetime_running_hours = {}; ++ int32_t lifetime_running_hours = {}; + + nlohmann::json json_payload; + try { +@@ -20442,7 +20442,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_running_h + return; + } + // Start parsing value +- lifetime_running_hours = json_payload.at("value").get(); ++ lifetime_running_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -20505,7 +20505,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_power_attribute_up + } + + +- uint32_t power = {}; ++ int32_t power = {}; + + nlohmann::json json_payload; + try { +@@ -20518,7 +20518,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_power_attribute_up + return; + } + // Start parsing value +- power = json_payload.at("value").get(); ++ power = json_payload.at("value").get(); + + // End parsing value + } +@@ -20581,7 +20581,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_energy_co + } + + +- uint32_t lifetime_energy_consumed = {}; ++ int32_t lifetime_energy_consumed = {}; + + nlohmann::json json_payload; + try { +@@ -20594,7 +20594,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_energy_co + return; + } + // Start parsing value +- lifetime_energy_consumed = json_payload.at("value").get(); ++ lifetime_energy_consumed = json_payload.at("value").get(); + + // End parsing value + } +@@ -21702,7 +21702,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_cooling_demand_attribute_update( + } + + +- uint8_t pi_cooling_demand = {}; ++ int8_t pi_cooling_demand = {}; + + nlohmann::json json_payload; + try { +@@ -21715,7 +21715,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_cooling_demand_attribute_update( + return; + } + // Start parsing value +- pi_cooling_demand = json_payload.at("value").get(); ++ pi_cooling_demand = json_payload.at("value").get(); + + // End parsing value + } +@@ -21778,7 +21778,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_heating_demand_attribute_update( + } + + +- uint8_t pi_heating_demand = {}; ++ int8_t pi_heating_demand = {}; + + nlohmann::json json_payload; + try { +@@ -21791,7 +21791,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_heating_demand_attribute_update( + return; + } + // Start parsing value +- pi_heating_demand = json_payload.at("value").get(); ++ pi_heating_demand = json_payload.at("value").get(); + + // End parsing value + } +@@ -23178,7 +23178,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_weekly_transitions_attribute + } + + +- uint8_t number_of_weekly_transitions = {}; ++ int8_t number_of_weekly_transitions = {}; + + nlohmann::json json_payload; + try { +@@ -23191,7 +23191,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_weekly_transitions_attribute + return; + } + // Start parsing value +- number_of_weekly_transitions = json_payload.at("value").get(); ++ number_of_weekly_transitions = json_payload.at("value").get(); + + // End parsing value + } +@@ -23254,7 +23254,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_daily_transitions_attribute_ + } + + +- uint8_t number_of_daily_transitions = {}; ++ int8_t number_of_daily_transitions = {}; + + nlohmann::json json_payload; + try { +@@ -23267,7 +23267,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_daily_transitions_attribute_ + return; + } + // Start parsing value +- number_of_daily_transitions = json_payload.at("value").get(); ++ number_of_daily_transitions = json_payload.at("value").get(); + + // End parsing value + } +@@ -23414,7 +23414,7 @@ static void uic_mqtt_dotdot_on_thermostat_temperature_setpoint_hold_duration_att + } + + +- uint16_t temperature_setpoint_hold_duration = {}; ++ int16_t temperature_setpoint_hold_duration = {}; + + nlohmann::json json_payload; + try { +@@ -23427,7 +23427,7 @@ static void uic_mqtt_dotdot_on_thermostat_temperature_setpoint_hold_duration_att + return; + } + // Start parsing value +- temperature_setpoint_hold_duration = json_payload.at("value").get(); ++ temperature_setpoint_hold_duration = json_payload.at("value").get(); + + // End parsing value + } +@@ -23802,7 +23802,7 @@ static void uic_mqtt_dotdot_on_thermostat_setpoint_change_source_timestamp_attri + } + + +- uint32_t setpoint_change_source_timestamp = {}; ++ uint8_t setpoint_change_source_timestamp = {}; + + nlohmann::json json_payload; + try { +@@ -23815,7 +23815,7 @@ static void uic_mqtt_dotdot_on_thermostat_setpoint_change_source_timestamp_attri + return; + } + // Start parsing value +- setpoint_change_source_timestamp = json_payload.at("value").get(); ++ setpoint_change_source_timestamp = json_payload.at("value").get(); + + // End parsing value + } +@@ -23878,7 +23878,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_attribute_update( + } + + +- uint8_t occupied_setback = {}; ++ int8_t occupied_setback = {}; + + nlohmann::json json_payload; + try { +@@ -23891,7 +23891,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_attribute_update( + return; + } + // Start parsing value +- occupied_setback = json_payload.at("value").get(); ++ occupied_setback = json_payload.at("value").get(); + + // End parsing value + } +@@ -23954,7 +23954,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_min_attribute_update( + } + + +- uint8_t occupied_setback_min = {}; ++ int8_t occupied_setback_min = {}; + + nlohmann::json json_payload; + try { +@@ -23967,7 +23967,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_min_attribute_update( + return; + } + // Start parsing value +- occupied_setback_min = json_payload.at("value").get(); ++ occupied_setback_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -24030,7 +24030,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_max_attribute_update( + } + + +- uint8_t occupied_setback_max = {}; ++ int8_t occupied_setback_max = {}; + + nlohmann::json json_payload; + try { +@@ -24043,7 +24043,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_max_attribute_update( + return; + } + // Start parsing value +- occupied_setback_max = json_payload.at("value").get(); ++ occupied_setback_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -24106,7 +24106,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_attribute_update( + } + + +- uint8_t unoccupied_setback = {}; ++ int8_t unoccupied_setback = {}; + + nlohmann::json json_payload; + try { +@@ -24119,7 +24119,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_attribute_update( + return; + } + // Start parsing value +- unoccupied_setback = json_payload.at("value").get(); ++ unoccupied_setback = json_payload.at("value").get(); + + // End parsing value + } +@@ -24182,7 +24182,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_min_attribute_updat + } + + +- uint8_t unoccupied_setback_min = {}; ++ int8_t unoccupied_setback_min = {}; + + nlohmann::json json_payload; + try { +@@ -24195,7 +24195,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_min_attribute_updat + return; + } + // Start parsing value +- unoccupied_setback_min = json_payload.at("value").get(); ++ unoccupied_setback_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -24258,7 +24258,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_max_attribute_updat + } + + +- uint8_t unoccupied_setback_max = {}; ++ int8_t unoccupied_setback_max = {}; + + nlohmann::json json_payload; + try { +@@ -24271,7 +24271,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_max_attribute_updat + return; + } + // Start parsing value +- unoccupied_setback_max = json_payload.at("value").get(); ++ unoccupied_setback_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -24334,7 +24334,7 @@ static void uic_mqtt_dotdot_on_thermostat_emergency_heat_delta_attribute_update( + } + + +- uint8_t emergency_heat_delta = {}; ++ int8_t emergency_heat_delta = {}; + + nlohmann::json json_payload; + try { +@@ -24347,7 +24347,7 @@ static void uic_mqtt_dotdot_on_thermostat_emergency_heat_delta_attribute_update( + return; + } + // Start parsing value +- emergency_heat_delta = json_payload.at("value").get(); ++ emergency_heat_delta = json_payload.at("value").get(); + + // End parsing value + } +@@ -24494,7 +24494,7 @@ static void uic_mqtt_dotdot_on_thermostat_ac_capacity_attribute_update( + } + + +- uint16_t ac_capacity = {}; ++ int16_t ac_capacity = {}; + + nlohmann::json json_payload; + try { +@@ -24507,7 +24507,7 @@ static void uic_mqtt_dotdot_on_thermostat_ac_capacity_attribute_update( + return; + } + // Start parsing value +- ac_capacity = json_payload.at("value").get(); ++ ac_capacity = json_payload.at("value").get(); + + // End parsing value + } +@@ -25706,7 +25706,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_relative_humidity_attrib + } + + +- uint8_t relative_humidity = {}; ++ int8_t relative_humidity = {}; + + nlohmann::json json_payload; + try { +@@ -25719,7 +25719,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_relative_humidity_attrib + return; + } + // Start parsing value +- relative_humidity = json_payload.at("value").get(); ++ relative_humidity = json_payload.at("value").get(); + + // End parsing value + } +@@ -25782,7 +25782,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_cooling + } + + +- uint8_t dehumidification_cooling = {}; ++ int8_t dehumidification_cooling = {}; + + nlohmann::json json_payload; + try { +@@ -25795,7 +25795,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_cooling + return; + } + // Start parsing value +- dehumidification_cooling = json_payload.at("value").get(); ++ dehumidification_cooling = json_payload.at("value").get(); + + // End parsing value + } +@@ -25858,7 +25858,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_rh_dehumidification_setp + } + + +- uint8_t rh_dehumidification_setpoint = {}; ++ int8_t rh_dehumidification_setpoint = {}; + + nlohmann::json json_payload; + try { +@@ -25871,7 +25871,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_rh_dehumidification_setp + return; + } + // Start parsing value +- rh_dehumidification_setpoint = json_payload.at("value").get(); ++ rh_dehumidification_setpoint = json_payload.at("value").get(); + + // End parsing value + } +@@ -26102,7 +26102,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_hystere + } + + +- uint8_t dehumidification_hysteresis = {}; ++ int8_t dehumidification_hysteresis = {}; + + nlohmann::json json_payload; + try { +@@ -26115,7 +26115,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_hystere + return; + } + // Start parsing value +- dehumidification_hysteresis = json_payload.at("value").get(); ++ dehumidification_hysteresis = json_payload.at("value").get(); + + // End parsing value + } +@@ -26178,7 +26178,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_max_coo + } + + +- uint8_t dehumidification_max_cool = {}; ++ int8_t dehumidification_max_cool = {}; + + nlohmann::json json_payload; + try { +@@ -26191,7 +26191,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_max_coo + return; + } + // Start parsing value +- dehumidification_max_cool = json_payload.at("value").get(); ++ dehumidification_max_cool = json_payload.at("value").get(); + + // End parsing value + } +@@ -26787,7 +26787,7 @@ static void uic_mqtt_dotdot_on_color_control_current_hue_attribute_update( + } + + +- uint8_t current_hue = {}; ++ int8_t current_hue = {}; + + nlohmann::json json_payload; + try { +@@ -26800,7 +26800,7 @@ static void uic_mqtt_dotdot_on_color_control_current_hue_attribute_update( + return; + } + // Start parsing value +- current_hue = json_payload.at("value").get(); ++ current_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -26863,7 +26863,7 @@ static void uic_mqtt_dotdot_on_color_control_current_saturation_attribute_update + } + + +- uint8_t current_saturation = {}; ++ int8_t current_saturation = {}; + + nlohmann::json json_payload; + try { +@@ -26876,7 +26876,7 @@ static void uic_mqtt_dotdot_on_color_control_current_saturation_attribute_update + return; + } + // Start parsing value +- current_saturation = json_payload.at("value").get(); ++ current_saturation = json_payload.at("value").get(); + + // End parsing value + } +@@ -26939,7 +26939,7 @@ static void uic_mqtt_dotdot_on_color_control_remaining_time_attribute_update( + } + + +- uint16_t remaining_time = {}; ++ int16_t remaining_time = {}; + + nlohmann::json json_payload; + try { +@@ -26952,7 +26952,7 @@ static void uic_mqtt_dotdot_on_color_control_remaining_time_attribute_update( + return; + } + // Start parsing value +- remaining_time = json_payload.at("value").get(); ++ remaining_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -27015,7 +27015,7 @@ static void uic_mqtt_dotdot_on_color_control_currentx_attribute_update( + } + + +- uint16_t currentx = {}; ++ int16_t currentx = {}; + + nlohmann::json json_payload; + try { +@@ -27028,7 +27028,7 @@ static void uic_mqtt_dotdot_on_color_control_currentx_attribute_update( + return; + } + // Start parsing value +- currentx = json_payload.at("value").get(); ++ currentx = json_payload.at("value").get(); + + // End parsing value + } +@@ -27091,7 +27091,7 @@ static void uic_mqtt_dotdot_on_color_control_currenty_attribute_update( + } + + +- uint16_t currenty = {}; ++ int16_t currenty = {}; + + nlohmann::json json_payload; + try { +@@ -27104,7 +27104,7 @@ static void uic_mqtt_dotdot_on_color_control_currenty_attribute_update( + return; + } + // Start parsing value +- currenty = json_payload.at("value").get(); ++ currenty = json_payload.at("value").get(); + + // End parsing value + } +@@ -27327,7 +27327,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temperature_mireds_attribute_ + } + + +- uint16_t color_temperature_mireds = {}; ++ int16_t color_temperature_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -27340,7 +27340,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temperature_mireds_attribute_ + return; + } + // Start parsing value +- color_temperature_mireds = json_payload.at("value").get(); ++ color_temperature_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -27563,7 +27563,7 @@ static void uic_mqtt_dotdot_on_color_control_number_of_primaries_attribute_updat + } + + +- uint8_t number_of_primaries = {}; ++ int8_t number_of_primaries = {}; + + nlohmann::json json_payload; + try { +@@ -27576,7 +27576,7 @@ static void uic_mqtt_dotdot_on_color_control_number_of_primaries_attribute_updat + return; + } + // Start parsing value +- number_of_primaries = json_payload.at("value").get(); ++ number_of_primaries = json_payload.at("value").get(); + + // End parsing value + } +@@ -27639,7 +27639,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1x_attribute_update( + } + + +- uint16_t primary1x = {}; ++ int16_t primary1x = {}; + + nlohmann::json json_payload; + try { +@@ -27652,7 +27652,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1x_attribute_update( + return; + } + // Start parsing value +- primary1x = json_payload.at("value").get(); ++ primary1x = json_payload.at("value").get(); + + // End parsing value + } +@@ -27715,7 +27715,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1y_attribute_update( + } + + +- uint16_t primary1y = {}; ++ int16_t primary1y = {}; + + nlohmann::json json_payload; + try { +@@ -27728,7 +27728,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1y_attribute_update( + return; + } + // Start parsing value +- primary1y = json_payload.at("value").get(); ++ primary1y = json_payload.at("value").get(); + + // End parsing value + } +@@ -27791,7 +27791,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1_intensity_attribute_update + } + + +- uint8_t primary1_intensity = {}; ++ int8_t primary1_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -27804,7 +27804,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1_intensity_attribute_update + return; + } + // Start parsing value +- primary1_intensity = json_payload.at("value").get(); ++ primary1_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -27867,7 +27867,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2x_attribute_update( + } + + +- uint16_t primary2x = {}; ++ int16_t primary2x = {}; + + nlohmann::json json_payload; + try { +@@ -27880,7 +27880,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2x_attribute_update( + return; + } + // Start parsing value +- primary2x = json_payload.at("value").get(); ++ primary2x = json_payload.at("value").get(); + + // End parsing value + } +@@ -27943,7 +27943,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2y_attribute_update( + } + + +- uint16_t primary2y = {}; ++ int16_t primary2y = {}; + + nlohmann::json json_payload; + try { +@@ -27956,7 +27956,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2y_attribute_update( + return; + } + // Start parsing value +- primary2y = json_payload.at("value").get(); ++ primary2y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28019,7 +28019,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2_intensity_attribute_update + } + + +- uint8_t primary2_intensity = {}; ++ int8_t primary2_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28032,7 +28032,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2_intensity_attribute_update + return; + } + // Start parsing value +- primary2_intensity = json_payload.at("value").get(); ++ primary2_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28095,7 +28095,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3x_attribute_update( + } + + +- uint16_t primary3x = {}; ++ int16_t primary3x = {}; + + nlohmann::json json_payload; + try { +@@ -28108,7 +28108,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3x_attribute_update( + return; + } + // Start parsing value +- primary3x = json_payload.at("value").get(); ++ primary3x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28171,7 +28171,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3y_attribute_update( + } + + +- uint16_t primary3y = {}; ++ int16_t primary3y = {}; + + nlohmann::json json_payload; + try { +@@ -28184,7 +28184,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3y_attribute_update( + return; + } + // Start parsing value +- primary3y = json_payload.at("value").get(); ++ primary3y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28247,7 +28247,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3_intensity_attribute_update + } + + +- uint8_t primary3_intensity = {}; ++ int8_t primary3_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28260,7 +28260,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3_intensity_attribute_update + return; + } + // Start parsing value +- primary3_intensity = json_payload.at("value").get(); ++ primary3_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28323,7 +28323,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4x_attribute_update( + } + + +- uint16_t primary4x = {}; ++ int16_t primary4x = {}; + + nlohmann::json json_payload; + try { +@@ -28336,7 +28336,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4x_attribute_update( + return; + } + // Start parsing value +- primary4x = json_payload.at("value").get(); ++ primary4x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28399,7 +28399,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4y_attribute_update( + } + + +- uint16_t primary4y = {}; ++ int16_t primary4y = {}; + + nlohmann::json json_payload; + try { +@@ -28412,7 +28412,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4y_attribute_update( + return; + } + // Start parsing value +- primary4y = json_payload.at("value").get(); ++ primary4y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28475,7 +28475,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4_intensity_attribute_update + } + + +- uint8_t primary4_intensity = {}; ++ int8_t primary4_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28488,7 +28488,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4_intensity_attribute_update + return; + } + // Start parsing value +- primary4_intensity = json_payload.at("value").get(); ++ primary4_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28551,7 +28551,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5x_attribute_update( + } + + +- uint16_t primary5x = {}; ++ int16_t primary5x = {}; + + nlohmann::json json_payload; + try { +@@ -28564,7 +28564,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5x_attribute_update( + return; + } + // Start parsing value +- primary5x = json_payload.at("value").get(); ++ primary5x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28627,7 +28627,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5y_attribute_update( + } + + +- uint16_t primary5y = {}; ++ int16_t primary5y = {}; + + nlohmann::json json_payload; + try { +@@ -28640,7 +28640,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5y_attribute_update( + return; + } + // Start parsing value +- primary5y = json_payload.at("value").get(); ++ primary5y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28703,7 +28703,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5_intensity_attribute_update + } + + +- uint8_t primary5_intensity = {}; ++ int8_t primary5_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28716,7 +28716,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5_intensity_attribute_update + return; + } + // Start parsing value +- primary5_intensity = json_payload.at("value").get(); ++ primary5_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28779,7 +28779,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6x_attribute_update( + } + + +- uint16_t primary6x = {}; ++ int16_t primary6x = {}; + + nlohmann::json json_payload; + try { +@@ -28792,7 +28792,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6x_attribute_update( + return; + } + // Start parsing value +- primary6x = json_payload.at("value").get(); ++ primary6x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28855,7 +28855,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6y_attribute_update( + } + + +- uint16_t primary6y = {}; ++ int16_t primary6y = {}; + + nlohmann::json json_payload; + try { +@@ -28868,7 +28868,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6y_attribute_update( + return; + } + // Start parsing value +- primary6y = json_payload.at("value").get(); ++ primary6y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28931,7 +28931,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6_intensity_attribute_update + } + + +- uint8_t primary6_intensity = {}; ++ int8_t primary6_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28944,7 +28944,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6_intensity_attribute_update + return; + } + // Start parsing value +- primary6_intensity = json_payload.at("value").get(); ++ primary6_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29007,7 +29007,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointx_attribute_update( + } + + +- uint16_t white_pointx = {}; ++ int16_t white_pointx = {}; + + nlohmann::json json_payload; + try { +@@ -29020,7 +29020,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointx_attribute_update( + return; + } + // Start parsing value +- white_pointx = json_payload.at("value").get(); ++ white_pointx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29083,7 +29083,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointy_attribute_update( + } + + +- uint16_t white_pointy = {}; ++ int16_t white_pointy = {}; + + nlohmann::json json_payload; + try { +@@ -29096,7 +29096,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointy_attribute_update( + return; + } + // Start parsing value +- white_pointy = json_payload.at("value").get(); ++ white_pointy = json_payload.at("value").get(); + + // End parsing value + } +@@ -29159,7 +29159,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointrx_attribute_update( + } + + +- uint16_t color_pointrx = {}; ++ int16_t color_pointrx = {}; + + nlohmann::json json_payload; + try { +@@ -29172,7 +29172,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointrx_attribute_update( + return; + } + // Start parsing value +- color_pointrx = json_payload.at("value").get(); ++ color_pointrx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29235,7 +29235,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointry_attribute_update( + } + + +- uint16_t color_pointry = {}; ++ int16_t color_pointry = {}; + + nlohmann::json json_payload; + try { +@@ -29248,7 +29248,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointry_attribute_update( + return; + } + // Start parsing value +- color_pointry = json_payload.at("value").get(); ++ color_pointry = json_payload.at("value").get(); + + // End parsing value + } +@@ -29311,7 +29311,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointr_intensity_attribute_up + } + + +- uint8_t color_pointr_intensity = {}; ++ int8_t color_pointr_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29324,7 +29324,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointr_intensity_attribute_up + return; + } + // Start parsing value +- color_pointr_intensity = json_payload.at("value").get(); ++ color_pointr_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29387,7 +29387,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgx_attribute_update( + } + + +- uint16_t color_pointgx = {}; ++ int16_t color_pointgx = {}; + + nlohmann::json json_payload; + try { +@@ -29400,7 +29400,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgx_attribute_update( + return; + } + // Start parsing value +- color_pointgx = json_payload.at("value").get(); ++ color_pointgx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29463,7 +29463,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgy_attribute_update( + } + + +- uint16_t color_pointgy = {}; ++ int16_t color_pointgy = {}; + + nlohmann::json json_payload; + try { +@@ -29476,7 +29476,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgy_attribute_update( + return; + } + // Start parsing value +- color_pointgy = json_payload.at("value").get(); ++ color_pointgy = json_payload.at("value").get(); + + // End parsing value + } +@@ -29539,7 +29539,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointg_intensity_attribute_up + } + + +- uint8_t color_pointg_intensity = {}; ++ int8_t color_pointg_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29552,7 +29552,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointg_intensity_attribute_up + return; + } + // Start parsing value +- color_pointg_intensity = json_payload.at("value").get(); ++ color_pointg_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29615,7 +29615,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointbx_attribute_update( + } + + +- uint16_t color_pointbx = {}; ++ int16_t color_pointbx = {}; + + nlohmann::json json_payload; + try { +@@ -29628,7 +29628,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointbx_attribute_update( + return; + } + // Start parsing value +- color_pointbx = json_payload.at("value").get(); ++ color_pointbx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29691,7 +29691,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointby_attribute_update( + } + + +- uint16_t color_pointby = {}; ++ int16_t color_pointby = {}; + + nlohmann::json json_payload; + try { +@@ -29704,7 +29704,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointby_attribute_update( + return; + } + // Start parsing value +- color_pointby = json_payload.at("value").get(); ++ color_pointby = json_payload.at("value").get(); + + // End parsing value + } +@@ -29767,7 +29767,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointb_intensity_attribute_up + } + + +- uint8_t color_pointb_intensity = {}; ++ int8_t color_pointb_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29780,7 +29780,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointb_intensity_attribute_up + return; + } + // Start parsing value +- color_pointb_intensity = json_payload.at("value").get(); ++ color_pointb_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29843,7 +29843,7 @@ static void uic_mqtt_dotdot_on_color_control_enhanced_current_hue_attribute_upda + } + + +- uint16_t enhanced_current_hue = {}; ++ int16_t enhanced_current_hue = {}; + + nlohmann::json json_payload; + try { +@@ -29856,7 +29856,7 @@ static void uic_mqtt_dotdot_on_color_control_enhanced_current_hue_attribute_upda + return; + } + // Start parsing value +- enhanced_current_hue = json_payload.at("value").get(); ++ enhanced_current_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30003,7 +30003,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_active_attribute_update( + } + + +- uint8_t color_loop_active = {}; ++ int8_t color_loop_active = {}; + + nlohmann::json json_payload; + try { +@@ -30016,7 +30016,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_active_attribute_update( + return; + } + // Start parsing value +- color_loop_active = json_payload.at("value").get(); ++ color_loop_active = json_payload.at("value").get(); + + // End parsing value + } +@@ -30079,7 +30079,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_direction_attribute_upda + } + + +- uint8_t color_loop_direction = {}; ++ int8_t color_loop_direction = {}; + + nlohmann::json json_payload; + try { +@@ -30092,7 +30092,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_direction_attribute_upda + return; + } + // Start parsing value +- color_loop_direction = json_payload.at("value").get(); ++ color_loop_direction = json_payload.at("value").get(); + + // End parsing value + } +@@ -30155,7 +30155,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_time_attribute_update( + } + + +- uint16_t color_loop_time = {}; ++ int16_t color_loop_time = {}; + + nlohmann::json json_payload; + try { +@@ -30168,7 +30168,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_time_attribute_update( + return; + } + // Start parsing value +- color_loop_time = json_payload.at("value").get(); ++ color_loop_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -30231,7 +30231,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_start_enhanced_hue_attri + } + + +- uint16_t color_loop_start_enhanced_hue = {}; ++ int16_t color_loop_start_enhanced_hue = {}; + + nlohmann::json json_payload; + try { +@@ -30244,7 +30244,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_start_enhanced_hue_attri + return; + } + // Start parsing value +- color_loop_start_enhanced_hue = json_payload.at("value").get(); ++ color_loop_start_enhanced_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30307,7 +30307,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_stored_enhanced_hue_attr + } + + +- uint16_t color_loop_stored_enhanced_hue = {}; ++ int16_t color_loop_stored_enhanced_hue = {}; + + nlohmann::json json_payload; + try { +@@ -30320,7 +30320,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_stored_enhanced_hue_attr + return; + } + // Start parsing value +- color_loop_stored_enhanced_hue = json_payload.at("value").get(); ++ color_loop_stored_enhanced_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30459,7 +30459,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_min_mireds_attr + } + + +- uint16_t color_temp_physical_min_mireds = {}; ++ int16_t color_temp_physical_min_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30472,7 +30472,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_min_mireds_attr + return; + } + // Start parsing value +- color_temp_physical_min_mireds = json_payload.at("value").get(); ++ color_temp_physical_min_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30535,7 +30535,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_max_mireds_attr + } + + +- uint16_t color_temp_physical_max_mireds = {}; ++ int16_t color_temp_physical_max_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30548,7 +30548,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_max_mireds_attr + return; + } + // Start parsing value +- color_temp_physical_max_mireds = json_payload.at("value").get(); ++ color_temp_physical_max_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30611,7 +30611,7 @@ static void uic_mqtt_dotdot_on_color_control_couple_color_temp_to_level_min_mire + } + + +- uint16_t couple_color_temp_to_level_min_mireds = {}; ++ int16_t couple_color_temp_to_level_min_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30624,7 +30624,7 @@ static void uic_mqtt_dotdot_on_color_control_couple_color_temp_to_level_min_mire + return; + } + // Start parsing value +- couple_color_temp_to_level_min_mireds = json_payload.at("value").get(); ++ couple_color_temp_to_level_min_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30687,7 +30687,7 @@ static void uic_mqtt_dotdot_on_color_control_start_up_color_temperature_mireds_a + } + + +- uint16_t start_up_color_temperature_mireds = {}; ++ int16_t start_up_color_temperature_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30700,7 +30700,7 @@ static void uic_mqtt_dotdot_on_color_control_start_up_color_temperature_mireds_a + return; + } + // Start parsing value +- start_up_color_temperature_mireds = json_payload.at("value").get(); ++ start_up_color_temperature_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -31222,7 +31222,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_min_level_attribut + } + + +- uint8_t physical_min_level = {}; ++ int8_t physical_min_level = {}; + + nlohmann::json json_payload; + try { +@@ -31235,7 +31235,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_min_level_attribut + return; + } + // Start parsing value +- physical_min_level = json_payload.at("value").get(); ++ physical_min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31298,7 +31298,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_max_level_attribut + } + + +- uint8_t physical_max_level = {}; ++ int8_t physical_max_level = {}; + + nlohmann::json json_payload; + try { +@@ -31311,7 +31311,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_max_level_attribut + return; + } + // Start parsing value +- physical_max_level = json_payload.at("value").get(); ++ physical_max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31450,7 +31450,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_min_level_attribute_update( + } + + +- uint8_t min_level = {}; ++ int8_t min_level = {}; + + nlohmann::json json_payload; + try { +@@ -31463,7 +31463,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_min_level_attribute_update( + return; + } + // Start parsing value +- min_level = json_payload.at("value").get(); ++ min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31526,7 +31526,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_max_level_attribute_update( + } + + +- uint8_t max_level = {}; ++ int8_t max_level = {}; + + nlohmann::json json_payload; + try { +@@ -31539,7 +31539,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_max_level_attribute_update( + return; + } + // Start parsing value +- max_level = json_payload.at("value").get(); ++ max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31602,7 +31602,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_level_attribute_up + } + + +- uint8_t power_on_level = {}; ++ int8_t power_on_level = {}; + + nlohmann::json json_payload; + try { +@@ -31615,7 +31615,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_level_attribute_up + return; + } + // Start parsing value +- power_on_level = json_payload.at("value").get(); ++ power_on_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31678,7 +31678,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_fade_time_attribut + } + + +- uint16_t power_on_fade_time = {}; ++ int16_t power_on_fade_time = {}; + + nlohmann::json json_payload; + try { +@@ -31691,7 +31691,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_fade_time_attribut + return; + } + // Start parsing value +- power_on_fade_time = json_payload.at("value").get(); ++ power_on_fade_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -31754,7 +31754,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_intrinsic_ballast_factor_at + } + + +- uint8_t intrinsic_ballast_factor = {}; ++ int8_t intrinsic_ballast_factor = {}; + + nlohmann::json json_payload; + try { +@@ -31767,7 +31767,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_intrinsic_ballast_factor_at + return; + } + // Start parsing value +- intrinsic_ballast_factor = json_payload.at("value").get(); ++ intrinsic_ballast_factor = json_payload.at("value").get(); + + // End parsing value + } +@@ -31830,7 +31830,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_ballast_factor_adjustment_a + } + + +- uint8_t ballast_factor_adjustment = {}; ++ int8_t ballast_factor_adjustment = {}; + + nlohmann::json json_payload; + try { +@@ -31843,7 +31843,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_ballast_factor_adjustment_a + return; + } + // Start parsing value +- ballast_factor_adjustment = json_payload.at("value").get(); ++ ballast_factor_adjustment = json_payload.at("value").get(); + + // End parsing value + } +@@ -31906,7 +31906,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_quantity_attribute_upd + } + + +- uint8_t lamp_quantity = {}; ++ int8_t lamp_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -31919,7 +31919,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_quantity_attribute_upd + return; + } + // Start parsing value +- lamp_quantity = json_payload.at("value").get(); ++ lamp_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -32134,7 +32134,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_rated_hours_attribute_ + } + + +- uint32_t lamp_rated_hours = {}; ++ int32_t lamp_rated_hours = {}; + + nlohmann::json json_payload; + try { +@@ -32147,7 +32147,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_rated_hours_attribute_ + return; + } + // Start parsing value +- lamp_rated_hours = json_payload.at("value").get(); ++ lamp_rated_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -32210,7 +32210,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_attribute_u + } + + +- uint32_t lamp_burn_hours = {}; ++ int32_t lamp_burn_hours = {}; + + nlohmann::json json_payload; + try { +@@ -32223,7 +32223,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_attribute_u + return; + } + // Start parsing value +- lamp_burn_hours = json_payload.at("value").get(); ++ lamp_burn_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -32362,7 +32362,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_trip_point_ + } + + +- uint32_t lamp_burn_hours_trip_point = {}; ++ int32_t lamp_burn_hours_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -32375,7 +32375,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_trip_point_ + return; + } + // Start parsing value +- lamp_burn_hours_trip_point = json_payload.at("value").get(); ++ lamp_burn_hours_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -32598,7 +32598,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_measured_value_attribute_ + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32611,7 +32611,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_measured_value_attribute_ + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32674,7 +32674,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_min_measured_value_attrib + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32687,7 +32687,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_min_measured_value_attrib + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32750,7 +32750,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_max_measured_value_attrib + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32763,7 +32763,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_max_measured_value_attrib + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32826,7 +32826,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_tolerance_attribute_updat + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -32839,7 +32839,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_tolerance_attribute_updat + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -33224,7 +33224,7 @@ static void uic_mqtt_dotdot_on_illuminance_level_sensing_illuminance_target_leve + } + + +- uint16_t illuminance_target_level = {}; ++ int16_t illuminance_target_level = {}; + + nlohmann::json json_payload; + try { +@@ -33237,7 +33237,7 @@ static void uic_mqtt_dotdot_on_illuminance_level_sensing_illuminance_target_leve + return; + } + // Start parsing value +- illuminance_target_level = json_payload.at("value").get(); ++ illuminance_target_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -33583,7 +33583,7 @@ static void uic_mqtt_dotdot_on_temperature_measurement_tolerance_attribute_updat + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -33596,7 +33596,7 @@ static void uic_mqtt_dotdot_on_temperature_measurement_tolerance_attribute_updat + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -33955,7 +33955,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_tolerance_attribute_update( + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -33968,7 +33968,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -34259,7 +34259,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_scaled_tolerance_attribute_u + } + + +- uint16_t scaled_tolerance = {}; ++ int16_t scaled_tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -34272,7 +34272,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_scaled_tolerance_attribute_u + return; + } + // Start parsing value +- scaled_tolerance = json_payload.at("value").get(); ++ scaled_tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -34514,7 +34514,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update( + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34527,7 +34527,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34590,298 +34590,298 @@ static void uic_mqtt_dotdot_on_flow_measurement_min_measured_value_attribute_upd + } + + +- uint16_t min_measured_value = {}; +- +- nlohmann::json json_payload; +- try { +- +- if (unretained == false) { +- json_payload = nlohmann::json::parse(std::string(message)); +- +- if (json_payload.find("value") == json_payload.end()) { +- sl_log_debug(LOG_TAG, "FlowMeasurement::MinMeasuredValue: Missing attribute element: 'value'\n"); +- return; +- } +-// Start parsing value +- min_measured_value = json_payload.at("value").get(); +- +- // End parsing value +- } +- +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); +- return; +- } +- +- uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback( +- static_cast(unid.c_str()), +- endpoint, +- unretained, +- update_type, +- min_measured_value +- ); +- +-} +-static void uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_update( +- const char *topic, +- const char *message, +- const size_t message_length) { +- if (uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback == nullptr) { +- return; +- } +- +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID / Endpoint ID from topic %s. Ignoring", +- topic); +- return; +- } +- +- std::string last_item; +- if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ +- sl_log_debug(LOG_TAG, +- "Error parsing last item from topic %s. Ignoring", +- topic); +- return; +- } +- +- uic_mqtt_dotdot_attribute_update_type_t update_type; +- if (last_item == "Reported") { +- update_type = UCL_REPORTED_UPDATED; +- } else if (last_item == "Desired") { +- update_type = UCL_DESIRED_UPDATED; +- } else { +- sl_log_debug(LOG_TAG, +- "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", +- topic); +- return; +- } +- +- // Empty message means unretained value. +- bool unretained = false; +- if (message_length == 0) { +- unretained = true; +- } +- +- +- uint16_t max_measured_value = {}; +- +- nlohmann::json json_payload; +- try { +- +- if (unretained == false) { +- json_payload = nlohmann::json::parse(std::string(message)); +- +- if (json_payload.find("value") == json_payload.end()) { +- sl_log_debug(LOG_TAG, "FlowMeasurement::MaxMeasuredValue: Missing attribute element: 'value'\n"); +- return; +- } +-// Start parsing value +- max_measured_value = json_payload.at("value").get(); +- +- // End parsing value +- } +- +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); +- return; +- } +- +- uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback( +- static_cast(unid.c_str()), +- endpoint, +- unretained, +- update_type, +- max_measured_value +- ); +- +-} +-static void uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update( +- const char *topic, +- const char *message, +- const size_t message_length) { +- if (uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback == nullptr) { +- return; +- } +- +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID / Endpoint ID from topic %s. Ignoring", +- topic); +- return; +- } +- +- std::string last_item; +- if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ +- sl_log_debug(LOG_TAG, +- "Error parsing last item from topic %s. Ignoring", +- topic); +- return; +- } +- +- uic_mqtt_dotdot_attribute_update_type_t update_type; +- if (last_item == "Reported") { +- update_type = UCL_REPORTED_UPDATED; +- } else if (last_item == "Desired") { +- update_type = UCL_DESIRED_UPDATED; +- } else { +- sl_log_debug(LOG_TAG, +- "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", +- topic); +- return; +- } +- +- // Empty message means unretained value. +- bool unretained = false; +- if (message_length == 0) { +- unretained = true; +- } +- +- +- uint16_t tolerance = {}; +- +- nlohmann::json json_payload; +- try { +- +- if (unretained == false) { +- json_payload = nlohmann::json::parse(std::string(message)); +- +- if (json_payload.find("value") == json_payload.end()) { +- sl_log_debug(LOG_TAG, "FlowMeasurement::Tolerance: Missing attribute element: 'value'\n"); +- return; +- } +-// Start parsing value +- tolerance = json_payload.at("value").get(); +- +- // End parsing value +- } +- +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); +- return; +- } +- +- uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback( +- static_cast(unid.c_str()), +- endpoint, +- unretained, +- update_type, +- tolerance +- ); +- +-} +- +-/////////////////////////////////////////////////////////////////////////////// +-// Attribute init functions for FlowMeasurement +-/////////////////////////////////////////////////////////////////////////////// +-sl_status_t uic_mqtt_dotdot_flow_measurement_attributes_init() +-{ +- std::string base_topic = "ucl/by-unid/+/+/"; +- +- std::string subscription_topic; +- if(uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback) { +- subscription_topic = base_topic + "FlowMeasurement/Attributes/MeasuredValue/#"; +- uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update); +- } +- if(uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback) { +- subscription_topic = base_topic + "FlowMeasurement/Attributes/MinMeasuredValue/#"; +- uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_min_measured_value_attribute_update); +- } +- if(uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback) { +- subscription_topic = base_topic + "FlowMeasurement/Attributes/MaxMeasuredValue/#"; +- uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_update); +- } +- if(uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback) { +- subscription_topic = base_topic + "FlowMeasurement/Attributes/Tolerance/#"; +- uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update); +- } +- +- return SL_STATUS_OK; +-} +- +- +-/////////////////////////////////////////////////////////////////////////////// +-// Callback setters and getters for FlowMeasurement +-/////////////////////////////////////////////////////////////////////////////// +-void uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback_t callback) +-{ +- uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback = callback; +-} +-void uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_t callback) +-{ +- uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback = callback; +-} +-void uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_t callback) +-{ +- uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback = callback; +-} +-void uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_t callback) +-{ +- uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback = callback; +-} +- +-// End of supported cluster. +- +-/////////////////////////////////////////////////////////////////////////////// +-// Callback pointers for RelativityHumidity +-/////////////////////////////////////////////////////////////////////////////// +-static uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback = nullptr; +-static uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback = nullptr; +-static uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback = nullptr; +-static uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback = nullptr; +- +-/////////////////////////////////////////////////////////////////////////////// +-// Attribute update handlers for RelativityHumidity +-/////////////////////////////////////////////////////////////////////////////// +-static void uic_mqtt_dotdot_on_relativity_humidity_measured_value_attribute_update( +- const char *topic, +- const char *message, +- const size_t message_length) { +- if (uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback == nullptr) { +- return; +- } +- +- std::string unid; +- uint8_t endpoint = 0; // Default value for endpoint-less topics. +- if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { +- sl_log_debug(LOG_TAG, +- "Error parsing UNID / Endpoint ID from topic %s. Ignoring", +- topic); +- return; +- } +- +- std::string last_item; +- if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ +- sl_log_debug(LOG_TAG, +- "Error parsing last item from topic %s. Ignoring", +- topic); +- return; +- } +- +- uic_mqtt_dotdot_attribute_update_type_t update_type; +- if (last_item == "Reported") { +- update_type = UCL_REPORTED_UPDATED; +- } else if (last_item == "Desired") { +- update_type = UCL_DESIRED_UPDATED; +- } else { +- sl_log_debug(LOG_TAG, +- "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", +- topic); +- return; +- } +- +- // Empty message means unretained value. +- bool unretained = false; +- if (message_length == 0) { +- unretained = true; +- } +- +- +- uint16_t measured_value = {}; ++ int16_t min_measured_value = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "FlowMeasurement::MinMeasuredValue: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ min_measured_value = json_payload.at("value").get(); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ min_measured_value ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ int16_t max_measured_value = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "FlowMeasurement::MaxMeasuredValue: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ max_measured_value = json_payload.at("value").get(); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ max_measured_value ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ int16_t tolerance = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "FlowMeasurement::Tolerance: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ tolerance = json_payload.at("value").get(); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ tolerance ++ ); ++ ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Attribute init functions for FlowMeasurement ++/////////////////////////////////////////////////////////////////////////////// ++sl_status_t uic_mqtt_dotdot_flow_measurement_attributes_init() ++{ ++ std::string base_topic = "ucl/by-unid/+/+/"; ++ ++ std::string subscription_topic; ++ if(uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback) { ++ subscription_topic = base_topic + "FlowMeasurement/Attributes/MeasuredValue/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update); ++ } ++ if(uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback) { ++ subscription_topic = base_topic + "FlowMeasurement/Attributes/MinMeasuredValue/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_min_measured_value_attribute_update); ++ } ++ if(uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback) { ++ subscription_topic = base_topic + "FlowMeasurement/Attributes/MaxMeasuredValue/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_update); ++ } ++ if(uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback) { ++ subscription_topic = base_topic + "FlowMeasurement/Attributes/Tolerance/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update); ++ } ++ ++ return SL_STATUS_OK; ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Callback setters and getters for FlowMeasurement ++/////////////////////////////////////////////////////////////////////////////// ++void uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback_t callback) ++{ ++ uic_mqtt_dotdot_flow_measurement_attribute_measured_value_callback = callback; ++} ++void uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_t callback) ++{ ++ uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback = callback; ++} ++void uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_t callback) ++{ ++ uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback = callback; ++} ++void uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_set(const uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_t callback) ++{ ++ uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback = callback; ++} ++ ++// End of supported cluster. ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Callback pointers for RelativityHumidity ++/////////////////////////////////////////////////////////////////////////////// ++static uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback = nullptr; ++static uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback = nullptr; ++static uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback = nullptr; ++static uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback_t uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback = nullptr; ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Attribute update handlers for RelativityHumidity ++/////////////////////////////////////////////////////////////////////////////// ++static void uic_mqtt_dotdot_on_relativity_humidity_measured_value_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34894,7 +34894,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_measured_value_attribute_upda + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34957,7 +34957,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_min_measured_value_attribute_ + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34970,7 +34970,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_min_measured_value_attribute_ + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -35033,7 +35033,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_max_measured_value_attribute_ + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -35046,7 +35046,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_max_measured_value_attribute_ + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -35109,7 +35109,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_tolerance_attribute_update( + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -35122,7 +35122,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -35492,7 +35492,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_occupied_to_unoccupied_dela + } + + +- uint16_t pir_occupied_to_unoccupied_delay = {}; ++ int16_t pir_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35505,7 +35505,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_occupied_to_unoccupied_dela + return; + } + // Start parsing value +- pir_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ pir_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35568,7 +35568,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_dela + } + + +- uint16_t pir_unoccupied_to_occupied_delay = {}; ++ int16_t pir_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35581,7 +35581,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_dela + return; + } + // Start parsing value +- pir_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ pir_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35644,7 +35644,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_thre + } + + +- uint8_t pir_unoccupied_to_occupied_threshold = {}; ++ int8_t pir_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -35657,7 +35657,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_thre + return; + } + // Start parsing value +- pir_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ pir_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -35720,7 +35720,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_occupied_to_unoccupi + } + + +- uint16_t ultrasonic_occupied_to_unoccupied_delay = {}; ++ int16_t ultrasonic_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35733,7 +35733,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_occupied_to_unoccupi + return; + } + // Start parsing value +- ultrasonic_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ ultrasonic_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35796,7 +35796,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + } + + +- uint16_t ultrasonic_unoccupied_to_occupied_delay = {}; ++ int16_t ultrasonic_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35809,7 +35809,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + return; + } + // Start parsing value +- ultrasonic_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ ultrasonic_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35872,7 +35872,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + } + + +- uint8_t ultrasonic_unoccupied_to_occupied_threshold = {}; ++ int8_t ultrasonic_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -35885,7 +35885,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + return; + } + // Start parsing value +- ultrasonic_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ ultrasonic_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -35948,7 +35948,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_occupied_to_un + } + + +- uint16_t physical_contact_occupied_to_unoccupied_delay = {}; ++ int16_t physical_contact_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35961,7 +35961,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_occupied_to_un + return; + } + // Start parsing value +- physical_contact_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ physical_contact_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -36024,7 +36024,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + } + + +- uint16_t physical_contact_unoccupied_to_occupied_delay = {}; ++ int16_t physical_contact_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -36037,7 +36037,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + return; + } + // Start parsing value +- physical_contact_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ physical_contact_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -36100,7 +36100,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + } + + +- uint8_t physical_contact_unoccupied_to_occupied_threshold = {}; ++ int8_t physical_contact_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -36113,7 +36113,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + return; + } + // Start parsing value +- physical_contact_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ physical_contact_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -36303,7 +36303,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_measured_value_attribute_update( + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36316,7 +36316,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36379,7 +36379,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_min_measured_value_attribute_update + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36392,7 +36392,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_min_measured_value_attribute_update + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36455,7 +36455,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_max_measured_value_attribute_update + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36468,7 +36468,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_max_measured_value_attribute_update + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36531,7 +36531,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_tolerance_attribute_update( + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -36544,7 +36544,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -36670,7 +36670,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_measured_value_attribute_update( + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36683,7 +36683,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36746,7 +36746,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_min_measured_value_attribute_updat + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36759,7 +36759,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_min_measured_value_attribute_updat + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36822,7 +36822,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_max_measured_value_attribute_updat + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36835,7 +36835,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_max_measured_value_attribute_updat + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36898,7 +36898,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_tolerance_attribute_update( + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -36911,7 +36911,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -37037,7 +37037,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_measured_valu + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37050,7 +37050,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_measured_valu + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37113,7 +37113,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_min_measured_ + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37126,7 +37126,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_min_measured_ + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37189,7 +37189,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_max_measured_ + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37202,7 +37202,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_max_measured_ + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37265,7 +37265,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_tolerance_att + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -37278,7 +37278,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_tolerance_att + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -37404,7 +37404,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_measured_value_attribute_u + } + + +- uint16_t measured_value = {}; ++ int16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37417,7 +37417,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_measured_value_attribute_u + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37480,7 +37480,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_min_measured_value_attribu + } + + +- uint16_t min_measured_value = {}; ++ int16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37493,7 +37493,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_min_measured_value_attribu + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37556,7 +37556,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_max_measured_value_attribu + } + + +- uint16_t max_measured_value = {}; ++ int16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37569,7 +37569,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_max_measured_value_attribu + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37632,7 +37632,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_tolerance_attribute_update + } + + +- uint16_t tolerance = {}; ++ int16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -37645,7 +37645,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_tolerance_attribute_update + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -39195,7 +39195,7 @@ static void uic_mqtt_dotdot_on_ias_zone_zoneid_attribute_update( + } + + +- uint8_t zoneid = {}; ++ int8_t zoneid = {}; + + nlohmann::json json_payload; + try { +@@ -39208,7 +39208,7 @@ static void uic_mqtt_dotdot_on_ias_zone_zoneid_attribute_update( + return; + } + // Start parsing value +- zoneid = json_payload.at("value").get(); ++ zoneid = json_payload.at("value").get(); + + // End parsing value + } +@@ -39271,7 +39271,7 @@ static void uic_mqtt_dotdot_on_ias_zone_number_of_zone_sensitivity_levels_suppor + } + + +- uint8_t number_of_zone_sensitivity_levels_supported = {}; ++ int8_t number_of_zone_sensitivity_levels_supported = {}; + + nlohmann::json json_payload; + try { +@@ -39284,7 +39284,7 @@ static void uic_mqtt_dotdot_on_ias_zone_number_of_zone_sensitivity_levels_suppor + return; + } + // Start parsing value +- number_of_zone_sensitivity_levels_supported = json_payload.at("value").get(); ++ number_of_zone_sensitivity_levels_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -39347,7 +39347,7 @@ static void uic_mqtt_dotdot_on_ias_zone_current_zone_sensitivity_level_attribute + } + + +- uint8_t current_zone_sensitivity_level = {}; ++ int8_t current_zone_sensitivity_level = {}; + + nlohmann::json json_payload; + try { +@@ -39360,7 +39360,7 @@ static void uic_mqtt_dotdot_on_ias_zone_current_zone_sensitivity_level_attribute + return; + } + // Start parsing value +- current_zone_sensitivity_level = json_payload.at("value").get(); ++ current_zone_sensitivity_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -39507,7 +39507,7 @@ static void uic_mqtt_dotdot_on_iaswd_max_duration_attribute_update( + } + + +- uint16_t max_duration = {}; ++ int16_t max_duration = {}; + + nlohmann::json json_payload; + try { +@@ -39520,7 +39520,7 @@ static void uic_mqtt_dotdot_on_iaswd_max_duration_attribute_update( + return; + } + // Start parsing value +- max_duration = json_payload.at("value").get(); ++ max_duration = json_payload.at("value").get(); + + // End parsing value + } +@@ -39644,7 +39644,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_delivered_attribute_up + } + + +- uint64_t current_summation_delivered = {}; ++ int64_t current_summation_delivered = {}; + + nlohmann::json json_payload; + try { +@@ -39657,7 +39657,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_delivered_attribute_up + return; + } + // Start parsing value +- current_summation_delivered = json_payload.at("value").get(); ++ current_summation_delivered = json_payload.at("value").get(); + + // End parsing value + } +@@ -39720,7 +39720,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_received_attribute_upd + } + + +- uint64_t current_summation_received = {}; ++ int64_t current_summation_received = {}; + + nlohmann::json json_payload; + try { +@@ -39733,7 +39733,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_received_attribute_upd + return; + } + // Start parsing value +- current_summation_received = json_payload.at("value").get(); ++ current_summation_received = json_payload.at("value").get(); + + // End parsing value + } +@@ -39796,7 +39796,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_attribute_u + } + + +- uint64_t current_max_demand_delivered = {}; ++ int64_t current_max_demand_delivered = {}; + + nlohmann::json json_payload; + try { +@@ -39809,7 +39809,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_attribute_u + return; + } + // Start parsing value +- current_max_demand_delivered = json_payload.at("value").get(); ++ current_max_demand_delivered = json_payload.at("value").get(); + + // End parsing value + } +@@ -40024,7 +40024,7 @@ static void uic_mqtt_dotdot_on_metering_reading_snap_shot_time_attribute_update( + } + + +- uint32_t reading_snap_shot_time = {}; ++ uint8_t reading_snap_shot_time = {}; + + nlohmann::json json_payload; + try { +@@ -40037,7 +40037,7 @@ static void uic_mqtt_dotdot_on_metering_reading_snap_shot_time_attribute_update( + return; + } + // Start parsing value +- reading_snap_shot_time = json_payload.at("value").get(); ++ reading_snap_shot_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40100,7 +40100,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_time_attrib + } + + +- uint32_t current_max_demand_delivered_time = {}; ++ uint8_t current_max_demand_delivered_time = {}; + + nlohmann::json json_payload; + try { +@@ -40113,7 +40113,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_time_attrib + return; + } + // Start parsing value +- current_max_demand_delivered_time = json_payload.at("value").get(); ++ current_max_demand_delivered_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40176,7 +40176,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_received_time_attribu + } + + +- uint32_t current_max_demand_received_time = {}; ++ uint8_t current_max_demand_received_time = {}; + + nlohmann::json json_payload; + try { +@@ -40189,7 +40189,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_received_time_attribu + return; + } + // Start parsing value +- current_max_demand_received_time = json_payload.at("value").get(); ++ current_max_demand_received_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40252,7 +40252,7 @@ static void uic_mqtt_dotdot_on_metering_default_update_period_attribute_update( + } + + +- uint8_t default_update_period = {}; ++ int8_t default_update_period = {}; + + nlohmann::json json_payload; + try { +@@ -40265,7 +40265,7 @@ static void uic_mqtt_dotdot_on_metering_default_update_period_attribute_update( + return; + } + // Start parsing value +- default_update_period = json_payload.at("value").get(); ++ default_update_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -40412,7 +40412,7 @@ static void uic_mqtt_dotdot_on_metering_current_inlet_energy_carrier_summation_a + } + + +- uint64_t current_inlet_energy_carrier_summation = {}; ++ int64_t current_inlet_energy_carrier_summation = {}; + + nlohmann::json json_payload; + try { +@@ -40425,7 +40425,7 @@ static void uic_mqtt_dotdot_on_metering_current_inlet_energy_carrier_summation_a + return; + } + // Start parsing value +- current_inlet_energy_carrier_summation = json_payload.at("value").get(); ++ current_inlet_energy_carrier_summation = json_payload.at("value").get(); + + // End parsing value + } +@@ -40488,7 +40488,7 @@ static void uic_mqtt_dotdot_on_metering_current_outlet_energy_carrier_summation_ + } + + +- uint64_t current_outlet_energy_carrier_summation = {}; ++ int64_t current_outlet_energy_carrier_summation = {}; + + nlohmann::json json_payload; + try { +@@ -40501,7 +40501,7 @@ static void uic_mqtt_dotdot_on_metering_current_outlet_energy_carrier_summation_ + return; + } + // Start parsing value +- current_outlet_energy_carrier_summation = json_payload.at("value").get(); ++ current_outlet_energy_carrier_summation = json_payload.at("value").get(); + + // End parsing value + } +@@ -40800,7 +40800,7 @@ static void uic_mqtt_dotdot_on_metering_multiplier_attribute_update( + } + + +- uint32_t multiplier = {}; ++ int32_t multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -40813,7 +40813,7 @@ static void uic_mqtt_dotdot_on_metering_multiplier_attribute_update( + return; + } + // Start parsing value +- multiplier = json_payload.at("value").get(); ++ multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -40876,7 +40876,7 @@ static void uic_mqtt_dotdot_on_metering_divisor_attribute_update( + } + + +- uint32_t divisor = {}; ++ int32_t divisor = {}; + + nlohmann::json json_payload; + try { +@@ -40889,7 +40889,7 @@ static void uic_mqtt_dotdot_on_metering_divisor_attribute_update( + return; + } + // Start parsing value +- divisor = json_payload.at("value").get(); ++ divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -42782,7 +42782,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_multiplier_attr + } + + +- uint16_t dc_voltage_multiplier = {}; ++ int16_t dc_voltage_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -42795,7 +42795,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_multiplier_attr + return; + } + // Start parsing value +- dc_voltage_multiplier = json_payload.at("value").get(); ++ dc_voltage_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -42858,7 +42858,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_divisor_attribu + } + + +- uint16_t dc_voltage_divisor = {}; ++ int16_t dc_voltage_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -42871,7 +42871,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_divisor_attribu + return; + } + // Start parsing value +- dc_voltage_divisor = json_payload.at("value").get(); ++ dc_voltage_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -42934,7 +42934,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_multiplier_attr + } + + +- uint16_t dc_current_multiplier = {}; ++ int16_t dc_current_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -42947,7 +42947,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_multiplier_attr + return; + } + // Start parsing value +- dc_current_multiplier = json_payload.at("value").get(); ++ dc_current_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -43010,7 +43010,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_divisor_attribu + } + + +- uint16_t dc_current_divisor = {}; ++ int16_t dc_current_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -43023,7 +43023,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_divisor_attribu + return; + } + // Start parsing value +- dc_current_divisor = json_payload.at("value").get(); ++ dc_current_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -43086,7 +43086,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_multiplier_attrib + } + + +- uint16_t dc_power_multiplier = {}; ++ int16_t dc_power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -43099,7 +43099,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_multiplier_attrib + return; + } + // Start parsing value +- dc_power_multiplier = json_payload.at("value").get(); ++ dc_power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -43162,7 +43162,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_divisor_attribute + } + + +- uint16_t dc_power_divisor = {}; ++ int16_t dc_power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -43175,7 +43175,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_divisor_attribute + return; + } + // Start parsing value +- dc_power_divisor = json_payload.at("value").get(); ++ dc_power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -43238,7 +43238,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_attribute_upd + } + + +- uint16_t ac_frequency = {}; ++ int16_t ac_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -43251,7 +43251,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_attribute_upd + return; + } + // Start parsing value +- ac_frequency = json_payload.at("value").get(); ++ ac_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -43314,7 +43314,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_min_attribute + } + + +- uint16_t ac_frequency_min = {}; ++ int16_t ac_frequency_min = {}; + + nlohmann::json json_payload; + try { +@@ -43327,7 +43327,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_min_attribute + return; + } + // Start parsing value +- ac_frequency_min = json_payload.at("value").get(); ++ ac_frequency_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -43390,7 +43390,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_max_attribute + } + + +- uint16_t ac_frequency_max = {}; ++ int16_t ac_frequency_max = {}; + + nlohmann::json json_payload; + try { +@@ -43403,7 +43403,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_max_attribute + return; + } + // Start parsing value +- ac_frequency_max = json_payload.at("value").get(); ++ ac_frequency_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -43466,7 +43466,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_neutral_current_attribute_ + } + + +- uint16_t neutral_current = {}; ++ int16_t neutral_current = {}; + + nlohmann::json json_payload; + try { +@@ -43479,7 +43479,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_neutral_current_attribute_ + return; + } + // Start parsing value +- neutral_current = json_payload.at("value").get(); ++ neutral_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -43694,7 +43694,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_total_apparent_power_attri + } + + +- uint32_t total_apparent_power = {}; ++ int32_t total_apparent_power = {}; + + nlohmann::json json_payload; + try { +@@ -43707,7 +43707,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_total_apparent_power_attri + return; + } + // Start parsing value +- total_apparent_power = json_payload.at("value").get(); ++ total_apparent_power = json_payload.at("value").get(); + + // End parsing value + } +@@ -44682,7 +44682,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_multiplier_at + } + + +- uint16_t ac_frequency_multiplier = {}; ++ int16_t ac_frequency_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -44695,7 +44695,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_multiplier_at + return; + } + // Start parsing value +- ac_frequency_multiplier = json_payload.at("value").get(); ++ ac_frequency_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -44758,7 +44758,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_divisor_attri + } + + +- uint16_t ac_frequency_divisor = {}; ++ int16_t ac_frequency_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -44771,7 +44771,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_divisor_attri + return; + } + // Start parsing value +- ac_frequency_divisor = json_payload.at("value").get(); ++ ac_frequency_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -44834,7 +44834,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_multiplier_attribute + } + + +- uint32_t power_multiplier = {}; ++ int32_t power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -44847,7 +44847,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_multiplier_attribute + return; + } + // Start parsing value +- power_multiplier = json_payload.at("value").get(); ++ power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -44910,7 +44910,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_divisor_attribute_up + } + + +- uint32_t power_divisor = {}; ++ int32_t power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -44923,7 +44923,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_divisor_attribute_up + return; + } + // Start parsing value +- power_divisor = json_payload.at("value").get(); ++ power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -45138,7 +45138,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_attribute_upd + } + + +- uint16_t line_current = {}; ++ int16_t line_current = {}; + + nlohmann::json json_payload; + try { +@@ -45151,7 +45151,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_attribute_upd + return; + } + // Start parsing value +- line_current = json_payload.at("value").get(); ++ line_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -45366,7 +45366,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_attribute_upda + } + + +- uint16_t rms_voltage = {}; ++ int16_t rms_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -45379,7 +45379,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_attribute_upda + return; + } + // Start parsing value +- rms_voltage = json_payload.at("value").get(); ++ rms_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -45442,7 +45442,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_attribute_ + } + + +- uint16_t rms_voltage_min = {}; ++ int16_t rms_voltage_min = {}; + + nlohmann::json json_payload; + try { +@@ -45455,7 +45455,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_attribute_ + return; + } + // Start parsing value +- rms_voltage_min = json_payload.at("value").get(); ++ rms_voltage_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -45518,7 +45518,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_attribute_ + } + + +- uint16_t rms_voltage_max = {}; ++ int16_t rms_voltage_max = {}; + + nlohmann::json json_payload; + try { +@@ -45531,7 +45531,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_attribute_ + return; + } + // Start parsing value +- rms_voltage_max = json_payload.at("value").get(); ++ rms_voltage_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -45594,7 +45594,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_attribute_upda + } + + +- uint16_t rms_current = {}; ++ int16_t rms_current = {}; + + nlohmann::json json_payload; + try { +@@ -45607,7 +45607,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_attribute_upda + return; + } + // Start parsing value +- rms_current = json_payload.at("value").get(); ++ rms_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -45670,7 +45670,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_attribute_ + } + + +- uint16_t rms_current_min = {}; ++ int16_t rms_current_min = {}; + + nlohmann::json json_payload; + try { +@@ -45683,7 +45683,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_attribute_ + return; + } + // Start parsing value +- rms_current_min = json_payload.at("value").get(); ++ rms_current_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -45746,7 +45746,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_attribute_ + } + + +- uint16_t rms_current_max = {}; ++ int16_t rms_current_max = {}; + + nlohmann::json json_payload; + try { +@@ -45759,7 +45759,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_attribute_ + return; + } + // Start parsing value +- rms_current_max = json_payload.at("value").get(); ++ rms_current_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -46126,7 +46126,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_attribute_u + } + + +- uint16_t apparent_power = {}; ++ int16_t apparent_power = {}; + + nlohmann::json json_payload; + try { +@@ -46139,7 +46139,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_attribute_u + return; + } + // Start parsing value +- apparent_power = json_payload.at("value").get(); ++ apparent_power = json_payload.at("value").get(); + + // End parsing value + } +@@ -46278,7 +46278,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- uint16_t average_rms_voltage_measurement_period = {}; ++ int16_t average_rms_voltage_measurement_period = {}; + + nlohmann::json json_payload; + try { +@@ -46291,7 +46291,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46354,7 +46354,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- uint16_t average_rms_over_voltage_counter = {}; ++ int16_t average_rms_over_voltage_counter = {}; + + nlohmann::json json_payload; + try { +@@ -46367,7 +46367,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter = json_payload.at("value").get(); ++ average_rms_over_voltage_counter = json_payload.at("value").get(); + + // End parsing value + } +@@ -46430,7 +46430,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- uint16_t average_rms_under_voltage_counter = {}; ++ int16_t average_rms_under_voltage_counter = {}; + + nlohmann::json json_payload; + try { +@@ -46443,7 +46443,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter = json_payload.at("value").get(); ++ average_rms_under_voltage_counter = json_payload.at("value").get(); + + // End parsing value + } +@@ -46506,7 +46506,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- uint16_t rms_extreme_over_voltage_period = {}; ++ int16_t rms_extreme_over_voltage_period = {}; + + nlohmann::json json_payload; + try { +@@ -46519,7 +46519,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46582,7 +46582,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- uint16_t rms_extreme_under_voltage_period = {}; ++ int16_t rms_extreme_under_voltage_period = {}; + + nlohmann::json json_payload; + try { +@@ -46595,7 +46595,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46658,7 +46658,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_att + } + + +- uint16_t rms_voltage_sag_period = {}; ++ int16_t rms_voltage_sag_period = {}; + + nlohmann::json json_payload; + try { +@@ -46671,7 +46671,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_att + return; + } + // Start parsing value +- rms_voltage_sag_period = json_payload.at("value").get(); ++ rms_voltage_sag_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46734,7 +46734,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_a + } + + +- uint16_t rms_voltage_swell_period = {}; ++ int16_t rms_voltage_swell_period = {}; + + nlohmann::json json_payload; + try { +@@ -46747,7 +46747,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_a + return; + } + // Start parsing value +- rms_voltage_swell_period = json_payload.at("value").get(); ++ rms_voltage_swell_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46810,7 +46810,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_multiplier_attr + } + + +- uint16_t ac_voltage_multiplier = {}; ++ int16_t ac_voltage_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -46823,7 +46823,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_multiplier_attr + return; + } + // Start parsing value +- ac_voltage_multiplier = json_payload.at("value").get(); ++ ac_voltage_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -46886,7 +46886,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_divisor_attribu + } + + +- uint16_t ac_voltage_divisor = {}; ++ int16_t ac_voltage_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -46899,7 +46899,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_divisor_attribu + return; + } + // Start parsing value +- ac_voltage_divisor = json_payload.at("value").get(); ++ ac_voltage_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -46962,7 +46962,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_multiplier_attr + } + + +- uint16_t ac_current_multiplier = {}; ++ int16_t ac_current_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -46975,7 +46975,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_multiplier_attr + return; + } + // Start parsing value +- ac_current_multiplier = json_payload.at("value").get(); ++ ac_current_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -47038,7 +47038,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_divisor_attribu + } + + +- uint16_t ac_current_divisor = {}; ++ int16_t ac_current_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -47051,7 +47051,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_divisor_attribu + return; + } + // Start parsing value +- ac_current_divisor = json_payload.at("value").get(); ++ ac_current_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -47114,7 +47114,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_multiplier_attrib + } + + +- uint16_t ac_power_multiplier = {}; ++ int16_t ac_power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -47127,7 +47127,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_multiplier_attrib + return; + } + // Start parsing value +- ac_power_multiplier = json_payload.at("value").get(); ++ ac_power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -47190,7 +47190,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_divisor_attribute + } + + +- uint16_t ac_power_divisor = {}; ++ int16_t ac_power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -47203,7 +47203,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_divisor_attribute + return; + } + // Start parsing value +- ac_power_divisor = json_payload.at("value").get(); ++ ac_power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -48330,7 +48330,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phb_attribute + } + + +- uint16_t line_current_phb = {}; ++ int16_t line_current_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48343,7 +48343,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phb_attribute + return; + } + // Start parsing value +- line_current_phb = json_payload.at("value").get(); ++ line_current_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48558,7 +48558,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phb_attribute_ + } + + +- uint16_t rms_voltage_phb = {}; ++ int16_t rms_voltage_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48571,7 +48571,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phb_attribute_ + return; + } + // Start parsing value +- rms_voltage_phb = json_payload.at("value").get(); ++ rms_voltage_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48634,7 +48634,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phb_attrib + } + + +- uint16_t rms_voltage_min_phb = {}; ++ int16_t rms_voltage_min_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48647,7 +48647,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phb_attrib + return; + } + // Start parsing value +- rms_voltage_min_phb = json_payload.at("value").get(); ++ rms_voltage_min_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48710,7 +48710,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phb_attrib + } + + +- uint16_t rms_voltage_max_phb = {}; ++ int16_t rms_voltage_max_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48723,7 +48723,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phb_attrib + return; + } + // Start parsing value +- rms_voltage_max_phb = json_payload.at("value").get(); ++ rms_voltage_max_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48786,7 +48786,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phb_attribute_ + } + + +- uint16_t rms_current_phb = {}; ++ int16_t rms_current_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48799,7 +48799,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phb_attribute_ + return; + } + // Start parsing value +- rms_current_phb = json_payload.at("value").get(); ++ rms_current_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48862,7 +48862,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phb_attrib + } + + +- uint16_t rms_current_min_phb = {}; ++ int16_t rms_current_min_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48875,7 +48875,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phb_attrib + return; + } + // Start parsing value +- rms_current_min_phb = json_payload.at("value").get(); ++ rms_current_min_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48938,7 +48938,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phb_attrib + } + + +- uint16_t rms_current_max_phb = {}; ++ int16_t rms_current_max_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48951,7 +48951,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phb_attrib + return; + } + // Start parsing value +- rms_current_max_phb = json_payload.at("value").get(); ++ rms_current_max_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49318,7 +49318,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phb_attribu + } + + +- uint16_t apparent_power_phb = {}; ++ int16_t apparent_power_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49331,7 +49331,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phb_attribu + return; + } + // Start parsing value +- apparent_power_phb = json_payload.at("value").get(); ++ apparent_power_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49470,7 +49470,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- uint16_t average_rms_voltage_measurement_period_phb = {}; ++ int16_t average_rms_voltage_measurement_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49483,7 +49483,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period_phb = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49546,7 +49546,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- uint16_t average_rms_over_voltage_counter_phb = {}; ++ int16_t average_rms_over_voltage_counter_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49559,7 +49559,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter_phb = json_payload.at("value").get(); ++ average_rms_over_voltage_counter_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49622,7 +49622,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- uint16_t average_rms_under_voltage_counter_phb = {}; ++ int16_t average_rms_under_voltage_counter_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49635,7 +49635,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter_phb = json_payload.at("value").get(); ++ average_rms_under_voltage_counter_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49698,7 +49698,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- uint16_t rms_extreme_over_voltage_period_phb = {}; ++ int16_t rms_extreme_over_voltage_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49711,7 +49711,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period_phb = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49774,7 +49774,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- uint16_t rms_extreme_under_voltage_period_phb = {}; ++ int16_t rms_extreme_under_voltage_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49787,7 +49787,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period_phb = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49850,7 +49850,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phb + } + + +- uint16_t rms_voltage_sag_period_phb = {}; ++ int16_t rms_voltage_sag_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49863,7 +49863,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phb + return; + } + // Start parsing value +- rms_voltage_sag_period_phb = json_payload.at("value").get(); ++ rms_voltage_sag_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49926,7 +49926,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + } + + +- uint16_t rms_voltage_swell_period_phb = {}; ++ int16_t rms_voltage_swell_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49939,7 +49939,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + return; + } + // Start parsing value +- rms_voltage_swell_period_phb = json_payload.at("value").get(); ++ rms_voltage_swell_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -50002,7 +50002,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phc_attribute + } + + +- uint16_t line_current_phc = {}; ++ int16_t line_current_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50015,7 +50015,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phc_attribute + return; + } + // Start parsing value +- line_current_phc = json_payload.at("value").get(); ++ line_current_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50230,7 +50230,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phc_attribute_ + } + + +- uint16_t rms_voltage_phc = {}; ++ int16_t rms_voltage_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50243,7 +50243,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phc_attribute_ + return; + } + // Start parsing value +- rms_voltage_phc = json_payload.at("value").get(); ++ rms_voltage_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50306,7 +50306,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phc_attrib + } + + +- uint16_t rms_voltage_min_phc = {}; ++ int16_t rms_voltage_min_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50319,7 +50319,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phc_attrib + return; + } + // Start parsing value +- rms_voltage_min_phc = json_payload.at("value").get(); ++ rms_voltage_min_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50382,7 +50382,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phc_attrib + } + + +- uint16_t rms_voltage_max_phc = {}; ++ int16_t rms_voltage_max_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50395,7 +50395,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phc_attrib + return; + } + // Start parsing value +- rms_voltage_max_phc = json_payload.at("value").get(); ++ rms_voltage_max_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50458,7 +50458,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phc_attribute_ + } + + +- uint16_t rms_current_phc = {}; ++ int16_t rms_current_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50471,7 +50471,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phc_attribute_ + return; + } + // Start parsing value +- rms_current_phc = json_payload.at("value").get(); ++ rms_current_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50534,7 +50534,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phc_attrib + } + + +- uint16_t rms_current_min_phc = {}; ++ int16_t rms_current_min_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50547,7 +50547,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phc_attrib + return; + } + // Start parsing value +- rms_current_min_phc = json_payload.at("value").get(); ++ rms_current_min_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50610,7 +50610,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phc_attrib + } + + +- uint16_t rms_current_max_phc = {}; ++ int16_t rms_current_max_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50623,7 +50623,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phc_attrib + return; + } + // Start parsing value +- rms_current_max_phc = json_payload.at("value").get(); ++ rms_current_max_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50990,7 +50990,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phc_attribu + } + + +- uint16_t apparent_power_phc = {}; ++ int16_t apparent_power_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51003,7 +51003,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phc_attribu + return; + } + // Start parsing value +- apparent_power_phc = json_payload.at("value").get(); ++ apparent_power_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51142,7 +51142,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- uint16_t average_rms_voltage_measurement_period_phc = {}; ++ int16_t average_rms_voltage_measurement_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51155,7 +51155,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period_phc = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51218,7 +51218,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- uint16_t average_rms_over_voltage_counter_phc = {}; ++ int16_t average_rms_over_voltage_counter_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51231,7 +51231,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter_phc = json_payload.at("value").get(); ++ average_rms_over_voltage_counter_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51294,7 +51294,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- uint16_t average_rms_under_voltage_counter_phc = {}; ++ int16_t average_rms_under_voltage_counter_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51307,7 +51307,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter_phc = json_payload.at("value").get(); ++ average_rms_under_voltage_counter_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51370,7 +51370,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- uint16_t rms_extreme_over_voltage_period_phc = {}; ++ int16_t rms_extreme_over_voltage_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51383,7 +51383,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period_phc = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51446,7 +51446,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- uint16_t rms_extreme_under_voltage_period_phc = {}; ++ int16_t rms_extreme_under_voltage_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51459,7 +51459,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period_phc = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51522,7 +51522,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phc + } + + +- uint16_t rms_voltage_sag_period_phc = {}; ++ int16_t rms_voltage_sag_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51535,7 +51535,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phc + return; + } + // Start parsing value +- rms_voltage_sag_period_phc = json_payload.at("value").get(); ++ rms_voltage_sag_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51598,7 +51598,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + } + + +- uint16_t rms_voltage_swell_period_phc = {}; ++ int16_t rms_voltage_swell_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51611,7 +51611,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + return; + } + // Start parsing value +- rms_voltage_swell_period_phc = json_payload.at("value").get(); ++ rms_voltage_swell_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -52749,7 +52749,7 @@ static void uic_mqtt_dotdot_on_diagnostics_number_of_resets_attribute_update( + } + + +- uint16_t number_of_resets = {}; ++ int16_t number_of_resets = {}; + + nlohmann::json json_payload; + try { +@@ -52762,7 +52762,7 @@ static void uic_mqtt_dotdot_on_diagnostics_number_of_resets_attribute_update( + return; + } + // Start parsing value +- number_of_resets = json_payload.at("value").get(); ++ number_of_resets = json_payload.at("value").get(); + + // End parsing value + } +@@ -52825,7 +52825,7 @@ static void uic_mqtt_dotdot_on_diagnostics_persistent_memory_writes_attribute_up + } + + +- uint16_t persistent_memory_writes = {}; ++ int16_t persistent_memory_writes = {}; + + nlohmann::json json_payload; + try { +@@ -52838,7 +52838,7 @@ static void uic_mqtt_dotdot_on_diagnostics_persistent_memory_writes_attribute_up + return; + } + // Start parsing value +- persistent_memory_writes = json_payload.at("value").get(); ++ persistent_memory_writes = json_payload.at("value").get(); + + // End parsing value + } +@@ -52901,7 +52901,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_bcast_attribute_update( + } + + +- uint32_t mac_rx_bcast = {}; ++ int32_t mac_rx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -52914,7 +52914,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_bcast_attribute_update( + return; + } + // Start parsing value +- mac_rx_bcast = json_payload.at("value").get(); ++ mac_rx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -52977,7 +52977,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_bcast_attribute_update( + } + + +- uint32_t mac_tx_bcast = {}; ++ int32_t mac_tx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -52990,7 +52990,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_bcast_attribute_update( + return; + } + // Start parsing value +- mac_tx_bcast = json_payload.at("value").get(); ++ mac_tx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53053,7 +53053,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_ucast_attribute_update( + } + + +- uint32_t mac_rx_ucast = {}; ++ int32_t mac_rx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53066,7 +53066,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_ucast_attribute_update( + return; + } + // Start parsing value +- mac_rx_ucast = json_payload.at("value").get(); ++ mac_rx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53129,7 +53129,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_attribute_update( + } + + +- uint32_t mac_tx_ucast = {}; ++ int32_t mac_tx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53142,7 +53142,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast = json_payload.at("value").get(); ++ mac_tx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53205,7 +53205,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_retry_attribute_update( + } + + +- uint16_t mac_tx_ucast_retry = {}; ++ int16_t mac_tx_ucast_retry = {}; + + nlohmann::json json_payload; + try { +@@ -53218,7 +53218,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_retry_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast_retry = json_payload.at("value").get(); ++ mac_tx_ucast_retry = json_payload.at("value").get(); + + // End parsing value + } +@@ -53281,7 +53281,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_fail_attribute_update( + } + + +- uint16_t mac_tx_ucast_fail = {}; ++ int16_t mac_tx_ucast_fail = {}; + + nlohmann::json json_payload; + try { +@@ -53294,7 +53294,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_fail_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast_fail = json_payload.at("value").get(); ++ mac_tx_ucast_fail = json_payload.at("value").get(); + + // End parsing value + } +@@ -53357,7 +53357,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_bcast_attribute_update( + } + + +- uint16_t aps_rx_bcast = {}; ++ int16_t aps_rx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -53370,7 +53370,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_bcast_attribute_update( + return; + } + // Start parsing value +- aps_rx_bcast = json_payload.at("value").get(); ++ aps_rx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53433,7 +53433,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_bcast_attribute_update( + } + + +- uint16_t aps_tx_bcast = {}; ++ int16_t aps_tx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -53446,7 +53446,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_bcast_attribute_update( + return; + } + // Start parsing value +- aps_tx_bcast = json_payload.at("value").get(); ++ aps_tx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53509,7 +53509,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_ucast_attribute_update( + } + + +- uint16_t aps_rx_ucast = {}; ++ int16_t aps_rx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53522,7 +53522,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_ucast_attribute_update( + return; + } + // Start parsing value +- aps_rx_ucast = json_payload.at("value").get(); ++ aps_rx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53585,7 +53585,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_success_attribute_update + } + + +- uint16_t aps_tx_ucast_success = {}; ++ int16_t aps_tx_ucast_success = {}; + + nlohmann::json json_payload; + try { +@@ -53598,7 +53598,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_success_attribute_update + return; + } + // Start parsing value +- aps_tx_ucast_success = json_payload.at("value").get(); ++ aps_tx_ucast_success = json_payload.at("value").get(); + + // End parsing value + } +@@ -53661,7 +53661,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_retry_attribute_update( + } + + +- uint16_t aps_tx_ucast_retry = {}; ++ int16_t aps_tx_ucast_retry = {}; + + nlohmann::json json_payload; + try { +@@ -53674,7 +53674,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_retry_attribute_update( + return; + } + // Start parsing value +- aps_tx_ucast_retry = json_payload.at("value").get(); ++ aps_tx_ucast_retry = json_payload.at("value").get(); + + // End parsing value + } +@@ -53737,7 +53737,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_fail_attribute_update( + } + + +- uint16_t aps_tx_ucast_fail = {}; ++ int16_t aps_tx_ucast_fail = {}; + + nlohmann::json json_payload; + try { +@@ -53750,7 +53750,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_fail_attribute_update( + return; + } + // Start parsing value +- aps_tx_ucast_fail = json_payload.at("value").get(); ++ aps_tx_ucast_fail = json_payload.at("value").get(); + + // End parsing value + } +@@ -53813,7 +53813,7 @@ static void uic_mqtt_dotdot_on_diagnostics_route_disc_initiated_attribute_update + } + + +- uint16_t route_disc_initiated = {}; ++ int16_t route_disc_initiated = {}; + + nlohmann::json json_payload; + try { +@@ -53826,7 +53826,7 @@ static void uic_mqtt_dotdot_on_diagnostics_route_disc_initiated_attribute_update + return; + } + // Start parsing value +- route_disc_initiated = json_payload.at("value").get(); ++ route_disc_initiated = json_payload.at("value").get(); + + // End parsing value + } +@@ -53889,7 +53889,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_added_attribute_update( + } + + +- uint16_t neighbor_added = {}; ++ int16_t neighbor_added = {}; + + nlohmann::json json_payload; + try { +@@ -53902,7 +53902,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_added_attribute_update( + return; + } + // Start parsing value +- neighbor_added = json_payload.at("value").get(); ++ neighbor_added = json_payload.at("value").get(); + + // End parsing value + } +@@ -53965,7 +53965,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_removed_attribute_update( + } + + +- uint16_t neighbor_removed = {}; ++ int16_t neighbor_removed = {}; + + nlohmann::json json_payload; + try { +@@ -53978,7 +53978,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_removed_attribute_update( + return; + } + // Start parsing value +- neighbor_removed = json_payload.at("value").get(); ++ neighbor_removed = json_payload.at("value").get(); + + // End parsing value + } +@@ -54041,7 +54041,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_stale_attribute_update( + } + + +- uint16_t neighbor_stale = {}; ++ int16_t neighbor_stale = {}; + + nlohmann::json json_payload; + try { +@@ -54054,7 +54054,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_stale_attribute_update( + return; + } + // Start parsing value +- neighbor_stale = json_payload.at("value").get(); ++ neighbor_stale = json_payload.at("value").get(); + + // End parsing value + } +@@ -54117,7 +54117,7 @@ static void uic_mqtt_dotdot_on_diagnostics_join_indication_attribute_update( + } + + +- uint16_t join_indication = {}; ++ int16_t join_indication = {}; + + nlohmann::json json_payload; + try { +@@ -54130,7 +54130,7 @@ static void uic_mqtt_dotdot_on_diagnostics_join_indication_attribute_update( + return; + } + // Start parsing value +- join_indication = json_payload.at("value").get(); ++ join_indication = json_payload.at("value").get(); + + // End parsing value + } +@@ -54193,7 +54193,7 @@ static void uic_mqtt_dotdot_on_diagnostics_child_moved_attribute_update( + } + + +- uint16_t child_moved = {}; ++ int16_t child_moved = {}; + + nlohmann::json json_payload; + try { +@@ -54206,7 +54206,7 @@ static void uic_mqtt_dotdot_on_diagnostics_child_moved_attribute_update( + return; + } + // Start parsing value +- child_moved = json_payload.at("value").get(); ++ child_moved = json_payload.at("value").get(); + + // End parsing value + } +@@ -54269,7 +54269,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwkfc_failure_attribute_update( + } + + +- uint16_t nwkfc_failure = {}; ++ int16_t nwkfc_failure = {}; + + nlohmann::json json_payload; + try { +@@ -54282,7 +54282,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwkfc_failure_attribute_update( + return; + } + // Start parsing value +- nwkfc_failure = json_payload.at("value").get(); ++ nwkfc_failure = json_payload.at("value").get(); + + // End parsing value + } +@@ -54345,7 +54345,7 @@ static void uic_mqtt_dotdot_on_diagnostics_apsfc_failure_attribute_update( + } + + +- uint16_t apsfc_failure = {}; ++ int16_t apsfc_failure = {}; + + nlohmann::json json_payload; + try { +@@ -54358,7 +54358,7 @@ static void uic_mqtt_dotdot_on_diagnostics_apsfc_failure_attribute_update( + return; + } + // Start parsing value +- apsfc_failure = json_payload.at("value").get(); ++ apsfc_failure = json_payload.at("value").get(); + + // End parsing value + } +@@ -54421,7 +54421,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_unauthorized_key_attribute_update + } + + +- uint16_t aps_unauthorized_key = {}; ++ int16_t aps_unauthorized_key = {}; + + nlohmann::json json_payload; + try { +@@ -54434,7 +54434,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_unauthorized_key_attribute_update + return; + } + // Start parsing value +- aps_unauthorized_key = json_payload.at("value").get(); ++ aps_unauthorized_key = json_payload.at("value").get(); + + // End parsing value + } +@@ -54497,7 +54497,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwk_decrypt_failures_attribute_update + } + + +- uint16_t nwk_decrypt_failures = {}; ++ int16_t nwk_decrypt_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54510,7 +54510,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwk_decrypt_failures_attribute_update + return; + } + // Start parsing value +- nwk_decrypt_failures = json_payload.at("value").get(); ++ nwk_decrypt_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54573,7 +54573,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_decrypt_failures_attribute_update + } + + +- uint16_t aps_decrypt_failures = {}; ++ int16_t aps_decrypt_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54586,7 +54586,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_decrypt_failures_attribute_update + return; + } + // Start parsing value +- aps_decrypt_failures = json_payload.at("value").get(); ++ aps_decrypt_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54649,7 +54649,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_buffer_allocate_failures_attri + } + + +- uint16_t packet_buffer_allocate_failures = {}; ++ int16_t packet_buffer_allocate_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54662,7 +54662,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_buffer_allocate_failures_attri + return; + } + // Start parsing value +- packet_buffer_allocate_failures = json_payload.at("value").get(); ++ packet_buffer_allocate_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54725,7 +54725,7 @@ static void uic_mqtt_dotdot_on_diagnostics_relayed_ucast_attribute_update( + } + + +- uint16_t relayed_ucast = {}; ++ int16_t relayed_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -54738,7 +54738,7 @@ static void uic_mqtt_dotdot_on_diagnostics_relayed_ucast_attribute_update( + return; + } + // Start parsing value +- relayed_ucast = json_payload.at("value").get(); ++ relayed_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -54801,7 +54801,7 @@ static void uic_mqtt_dotdot_on_diagnostics_phy_to_mac_queue_limit_reached_attrib + } + + +- uint16_t phy_to_mac_queue_limit_reached = {}; ++ int16_t phy_to_mac_queue_limit_reached = {}; + + nlohmann::json json_payload; + try { +@@ -54814,7 +54814,7 @@ static void uic_mqtt_dotdot_on_diagnostics_phy_to_mac_queue_limit_reached_attrib + return; + } + // Start parsing value +- phy_to_mac_queue_limit_reached = json_payload.at("value").get(); ++ phy_to_mac_queue_limit_reached = json_payload.at("value").get(); + + // End parsing value + } +@@ -54877,7 +54877,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_validate_drop_count_attribute_ + } + + +- uint16_t packet_validate_drop_count = {}; ++ int16_t packet_validate_drop_count = {}; + + nlohmann::json json_payload; + try { +@@ -54890,7 +54890,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_validate_drop_count_attribute_ + return; + } + // Start parsing value +- packet_validate_drop_count = json_payload.at("value").get(); ++ packet_validate_drop_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -54953,7 +54953,7 @@ static void uic_mqtt_dotdot_on_diagnostics_average_mac_retry_per_aps_message_sen + } + + +- uint16_t average_mac_retry_per_aps_message_sent = {}; ++ int16_t average_mac_retry_per_aps_message_sent = {}; + + nlohmann::json json_payload; + try { +@@ -54966,7 +54966,7 @@ static void uic_mqtt_dotdot_on_diagnostics_average_mac_retry_per_aps_message_sen + return; + } + // Start parsing value +- average_mac_retry_per_aps_message_sent = json_payload.at("value").get(); ++ average_mac_retry_per_aps_message_sent = json_payload.at("value").get(); + + // End parsing value + } +@@ -55029,7 +55029,7 @@ static void uic_mqtt_dotdot_on_diagnostics_last_messagelqi_attribute_update( + } + + +- uint8_t last_messagelqi = {}; ++ int8_t last_messagelqi = {}; + + nlohmann::json json_payload; + try { +@@ -55042,7 +55042,7 @@ static void uic_mqtt_dotdot_on_diagnostics_last_messagelqi_attribute_update( + return; + } + // Start parsing value +- last_messagelqi = json_payload.at("value").get(); ++ last_messagelqi = json_payload.at("value").get(); + + // End parsing value + } +@@ -55666,7 +55666,7 @@ static void uic_mqtt_dotdot_on_state_endpoint_id_list_attribute_update( + } + + +- std::vector endpoint_id_list; ++ std::vector endpoint_id_list; + size_t endpoint_id_list_count = 0; + + nlohmann::json json_payload; +@@ -55682,7 +55682,7 @@ static void uic_mqtt_dotdot_on_state_endpoint_id_list_attribute_update( + // Start parsing value + auto &endpoint_id_list_json = json_payload.at("value"); + for (size_t i = 0; i < endpoint_id_list_json.size(); i++) { +- endpoint_id_list.push_back(endpoint_id_list_json.at(i).get()); ++ endpoint_id_list.push_back(endpoint_id_list_json.at(i).get()); + } + // Take our vector and pack it into the updated state + endpoint_id_list_count = endpoint_id_list.size(); +@@ -55917,7 +55917,7 @@ static void uic_mqtt_dotdot_on_state_maximum_command_delay_attribute_update( + } + + +- uint32_t maximum_command_delay = {}; ++ int32_t maximum_command_delay = {}; + + nlohmann::json json_payload; + try { +@@ -55930,7 +55930,7 @@ static void uic_mqtt_dotdot_on_state_maximum_command_delay_attribute_update( + return; + } + // Start parsing value +- maximum_command_delay = json_payload.at("value").get(); ++ maximum_command_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -56324,7 +56324,7 @@ static void uic_mqtt_dotdot_on_binding_binding_table_attribute_update( + BindingObject element = {}; + element.ClusterName = binding_table_json.at(i).at("ClusterName").get_ptr()->c_str(); + element.DestinationUnid = binding_table_json.at(i).at("DestinationUnid").get_ptr()->c_str(); +- element.DestinationEp = binding_table_json.at(i).at("DestinationEp").get(); ++ element.DestinationEp = binding_table_json.at(i).at("DestinationEp").get(); + binding_table.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -56470,7 +56470,7 @@ static void uic_mqtt_dotdot_on_system_metrics_reporting_interval_seconds_attribu + } + + +- uint32_t reporting_interval_seconds = {}; ++ int32_t reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -56483,7 +56483,7 @@ static void uic_mqtt_dotdot_on_system_metrics_reporting_interval_seconds_attribu + return; + } + // Start parsing value +- reporting_interval_seconds = json_payload.at("value").get(); ++ reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -57598,10 +57598,10 @@ static void uic_mqtt_dotdot_on_system_metrics_disks_counters_attribute_update( + for (size_t i = 0; i < disks_counters_json.size(); i++) { + DiskIOCounters element = {}; + element.UUID = disks_counters_json.at(i).at("UUID").get_ptr()->c_str(); +- element.ReadCount = disks_counters_json.at(i).at("ReadCount").get(); +- element.WriteCount = disks_counters_json.at(i).at("WriteCount").get(); +- element.ReadBytes = disks_counters_json.at(i).at("ReadBytes").get(); +- element.WriteBytes = disks_counters_json.at(i).at("WriteBytes").get(); ++ element.ReadCount = disks_counters_json.at(i).at("ReadCount").get(); ++ element.WriteCount = disks_counters_json.at(i).at("WriteCount").get(); ++ element.ReadBytes = disks_counters_json.at(i).at("ReadBytes").get(); ++ element.WriteBytes = disks_counters_json.at(i).at("WriteBytes").get(); + disks_counters.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -57687,14 +57687,14 @@ static void uic_mqtt_dotdot_on_system_metrics_network_interfaces_data_attribute_ + for (size_t i = 0; i < network_interfaces_data_json.size(); i++) { + NetworkInterfaceData element = {}; + element.InterfaceName = network_interfaces_data_json.at(i).at("InterfaceName").get_ptr()->c_str(); +- element.BytesSent = network_interfaces_data_json.at(i).at("BytesSent").get(); +- element.BytesReceived = network_interfaces_data_json.at(i).at("BytesReceived").get(); +- element.PacketsSent = network_interfaces_data_json.at(i).at("PacketsSent").get(); +- element.PacketsReceived = network_interfaces_data_json.at(i).at("PacketsReceived").get(); +- element.ErrorsIn = network_interfaces_data_json.at(i).at("ErrorsIn").get(); +- element.ErrorsOut = network_interfaces_data_json.at(i).at("ErrorsOut").get(); +- element.DropIn = network_interfaces_data_json.at(i).at("DropIn").get(); +- element.DropOut = network_interfaces_data_json.at(i).at("DropOut").get(); ++ element.BytesSent = network_interfaces_data_json.at(i).at("BytesSent").get(); ++ element.BytesReceived = network_interfaces_data_json.at(i).at("BytesReceived").get(); ++ element.PacketsSent = network_interfaces_data_json.at(i).at("PacketsSent").get(); ++ element.PacketsReceived = network_interfaces_data_json.at(i).at("PacketsReceived").get(); ++ element.ErrorsIn = network_interfaces_data_json.at(i).at("ErrorsIn").get(); ++ element.ErrorsOut = network_interfaces_data_json.at(i).at("ErrorsOut").get(); ++ element.DropIn = network_interfaces_data_json.at(i).at("DropIn").get(); ++ element.DropOut = network_interfaces_data_json.at(i).at("DropOut").get(); + network_interfaces_data.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -58000,7 +58000,7 @@ static void uic_mqtt_dotdot_on_system_metrics_uptime_minutes_attribute_update( + } + + +- uint64_t uptime_minutes = {}; ++ int64_t uptime_minutes = {}; + + nlohmann::json json_payload; + try { +@@ -58013,7 +58013,7 @@ static void uic_mqtt_dotdot_on_system_metrics_uptime_minutes_attribute_update( + return; + } + // Start parsing value +- uptime_minutes = json_payload.at("value").get(); ++ uptime_minutes = json_payload.at("value").get(); + + // End parsing value + } +@@ -58532,7 +58532,7 @@ static void uic_mqtt_dotdot_on_system_metrics_system_interrupts_attribute_update + } + + +- uint64_t system_interrupts = {}; ++ int64_t system_interrupts = {}; + + nlohmann::json json_payload; + try { +@@ -58545,7 +58545,7 @@ static void uic_mqtt_dotdot_on_system_metrics_system_interrupts_attribute_update + return; + } + // Start parsing value +- system_interrupts = json_payload.at("value").get(); ++ system_interrupts = json_payload.at("value").get(); + + // End parsing value + } +@@ -59185,7 +59185,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_uptime_minutes_attribute_u + } + + +- uint64_t uptime_minutes = {}; ++ int64_t uptime_minutes = {}; + + nlohmann::json json_payload; + try { +@@ -59198,7 +59198,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_uptime_minutes_attribute_u + return; + } + // Start parsing value +- uptime_minutes = json_payload.at("value").get(); ++ uptime_minutes = json_payload.at("value").get(); + + // End parsing value + } +@@ -59261,7 +59261,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_process_id_attribute_updat + } + + +- uint64_t process_id = {}; ++ int64_t process_id = {}; + + nlohmann::json json_payload; + try { +@@ -59274,7 +59274,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_process_id_attribute_updat + return; + } + // Start parsing value +- process_id = json_payload.at("value").get(); ++ process_id = json_payload.at("value").get(); + + // End parsing value + } +@@ -59649,7 +59649,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_statistics_reporting_ + } + + +- uint32_t mqtt_statistics_reporting_interval_seconds = {}; ++ int32_t mqtt_statistics_reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -59662,7 +59662,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_statistics_reporting_ + return; + } + // Start parsing value +- mqtt_statistics_reporting_interval_seconds = json_payload.at("value").get(); ++ mqtt_statistics_reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -59725,7 +59725,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_sent_attribu + } + + +- uint64_t mqtt_messages_sent = {}; ++ int64_t mqtt_messages_sent = {}; + + nlohmann::json json_payload; + try { +@@ -59738,7 +59738,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_sent_attribu + return; + } + // Start parsing value +- mqtt_messages_sent = json_payload.at("value").get(); ++ mqtt_messages_sent = json_payload.at("value").get(); + + // End parsing value + } +@@ -59801,7 +59801,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_received_att + } + + +- uint64_t mqtt_messages_received = {}; ++ int64_t mqtt_messages_received = {}; + + nlohmann::json json_payload; + try { +@@ -59814,7 +59814,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_received_att + return; + } + // Start parsing value +- mqtt_messages_received = json_payload.at("value").get(); ++ mqtt_messages_received = json_payload.at("value").get(); + + // End parsing value + } +@@ -59877,7 +59877,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_subscription_count_at + } + + +- uint64_t mqtt_subscription_count = {}; ++ int64_t mqtt_subscription_count = {}; + + nlohmann::json json_payload; + try { +@@ -59890,7 +59890,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_subscription_count_at + return; + } + // Start parsing value +- mqtt_subscription_count = json_payload.at("value").get(); ++ mqtt_subscription_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -60181,7 +60181,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_application_statistics_rep + } + + +- uint32_t application_statistics_reporting_interval_seconds = {}; ++ int32_t application_statistics_reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -60194,7 +60194,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_application_statistics_rep + return; + } + // Start parsing value +- application_statistics_reporting_interval_seconds = json_payload.at("value").get(); ++ application_statistics_reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -61063,7 +61063,7 @@ static void uic_mqtt_dotdot_on_configuration_parameters_configuration_parameters + auto &configuration_parameters_json = json_payload.at("value"); + for (size_t i = 0; i < configuration_parameters_json.size(); i++) { + ConfigurationParameter element = {}; +- element.ParameterId = configuration_parameters_json.at(i).at("ParameterId").get(); ++ element.ParameterId = configuration_parameters_json.at(i).at("ParameterId").get(); + element.Value = configuration_parameters_json.at(i).at("Value").get(); + element.Name = configuration_parameters_json.at(i).at("Name").get_ptr()->c_str(); + element.Info = configuration_parameters_json.at(i).at("Info").get_ptr()->c_str(); +@@ -61125,6 +61125,713 @@ void uic_mqtt_dotdot_configuration_parameters_attribute_configuration_parameters + + // End of supported cluster. + ++/////////////////////////////////////////////////////////////////////////////// ++// Callback pointers for UserCredential ++/////////////////////////////////////////////////////////////////////////////// ++static uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_t uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_t uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_t uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_t uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_t uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_t uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_t uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback = nullptr; ++static uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_t uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback = nullptr; ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Attribute update handlers for UserCredential ++/////////////////////////////////////////////////////////////////////////////// ++static void uic_mqtt_dotdot_on_user_credential_supported_user_unique_identifiers_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ int16_t supported_user_unique_identifiers = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportedUserUniqueIdentifiers: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ supported_user_unique_identifiers = json_payload.at("value").get(); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ supported_user_unique_identifiers ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_supported_credential_rules_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ uint8_t supported_credential_rules = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportedCredentialRules: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ supported_credential_rules = uic_dotdot_mqtt::get_bitmap_decimal_value("value", json_payload, UserCredentialSupportedCredentialRules); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ supported_credential_rules ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_supported_credential_types_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ uint16_t supported_credential_types = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportedCredentialTypes: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ supported_credential_types = uic_dotdot_mqtt::get_bitmap_decimal_value("value", json_payload, UserCredentialSupportedCredentialTypes); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ supported_credential_types ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_supported_user_types_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ uint16_t supported_user_types = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportedUserTypes: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ supported_user_types = uic_dotdot_mqtt::get_bitmap_decimal_value("value", json_payload, UserCredentialSupportedUserTypes); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ supported_user_types ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_support_credential_checksum_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ bool support_credential_checksum = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportCredentialChecksum: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ support_credential_checksum = get_bool_from_json(json_payload, "value"); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ support_credential_checksum ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_support_admin_pin_code_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ bool support_admin_pin_code = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportAdminPinCode: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ support_admin_pin_code = get_bool_from_json(json_payload, "value"); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ support_admin_pin_code ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_support_admin_pin_code_deactivation_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ bool support_admin_pin_code_deactivation = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SupportAdminPinCodeDeactivation: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ support_admin_pin_code_deactivation = get_bool_from_json(json_payload, "value"); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ support_admin_pin_code_deactivation ++ ); ++ ++} ++static void uic_mqtt_dotdot_on_user_credential_admin_pin_code_attribute_update( ++ const char *topic, ++ const char *message, ++ const size_t message_length) { ++ if (uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback == nullptr) { ++ return; ++ } ++ ++ std::string unid; ++ uint8_t endpoint = 0; // Default value for endpoint-less topics. ++ if(! uic_dotdot_mqtt::parse_topic(topic,unid,endpoint)) { ++ sl_log_debug(LOG_TAG, ++ "Error parsing UNID / Endpoint ID from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ std::string last_item; ++ if (SL_STATUS_OK != uic_dotdot_mqtt::get_topic_last_item(topic,last_item)){ ++ sl_log_debug(LOG_TAG, ++ "Error parsing last item from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ uic_mqtt_dotdot_attribute_update_type_t update_type; ++ if (last_item == "Reported") { ++ update_type = UCL_REPORTED_UPDATED; ++ } else if (last_item == "Desired") { ++ update_type = UCL_DESIRED_UPDATED; ++ } else { ++ sl_log_debug(LOG_TAG, ++ "Unknown value type (neither Desired/Reported) for topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Empty message means unretained value. ++ bool unretained = false; ++ if (message_length == 0) { ++ unretained = true; ++ } ++ ++ ++ const char* admin_pin_code = {}; ++ ++ nlohmann::json json_payload; ++ try { ++ ++ if (unretained == false) { ++ json_payload = nlohmann::json::parse(std::string(message)); ++ ++ if (json_payload.find("value") == json_payload.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AdminPinCode: Missing attribute element: 'value'\n"); ++ return; ++ } ++// Start parsing value ++ admin_pin_code = json_payload.at("value").get_ptr()->c_str(); ++ ++ // End parsing value ++ } ++ ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "value", message); ++ return; ++ } ++ ++ uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback( ++ static_cast(unid.c_str()), ++ endpoint, ++ unretained, ++ update_type, ++ admin_pin_code ++ ); ++ ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Attribute init functions for UserCredential ++/////////////////////////////////////////////////////////////////////////////// ++sl_status_t uic_mqtt_dotdot_user_credential_attributes_init() ++{ ++ std::string base_topic = "ucl/by-unid/+/+/"; ++ ++ std::string subscription_topic; ++ if(uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportedUserUniqueIdentifiers/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_supported_user_unique_identifiers_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportedCredentialRules/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_supported_credential_rules_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportedCredentialTypes/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_supported_credential_types_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportedUserTypes/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_supported_user_types_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportCredentialChecksum/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_support_credential_checksum_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportAdminPinCode/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_support_admin_pin_code_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/SupportAdminPinCodeDeactivation/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_support_admin_pin_code_deactivation_attribute_update); ++ } ++ if(uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback) { ++ subscription_topic = base_topic + "UserCredential/Attributes/AdminPinCode/#"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), &uic_mqtt_dotdot_on_user_credential_admin_pin_code_attribute_update); ++ } ++ ++ return SL_STATUS_OK; ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Callback setters and getters for UserCredential ++/////////////////////////////////////////////////////////////////////////////// ++void uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_supported_user_unique_identifiers_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_supported_credential_types_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_set(const uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_supported_user_types_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_support_credential_checksum_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_set(const uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_support_admin_pin_code_deactivation_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_set(const uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_user_credential_attribute_admin_pin_code_callback = callback; ++} ++ ++// End of supported cluster. ++ + /////////////////////////////////////////////////////////////////////////////// + // Callback pointers for ProtocolController-NetworkManagement + /////////////////////////////////////////////////////////////////////////////// +@@ -61310,7 +62017,7 @@ static void uic_mqtt_dotdot_on_descriptor_device_type_list_attribute_update( + for (size_t i = 0; i < device_type_list_json.size(); i++) { + DeviceTypeStruct element = {}; + element.DeviceType = device_type_list_json.at(i).at("DeviceType").get(); +- element.Revision = device_type_list_json.at(i).at("Revision").get(); ++ element.Revision = device_type_list_json.at(i).at("Revision").get(); + device_type_list.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -62660,7 +63367,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_humidifier_setpoint_precis + } + + +- uint8_t humidifier_setpoint_precision = {}; ++ int8_t humidifier_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -62673,7 +63380,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_humidifier_setpoint_precis + return; + } + // Start parsing value +- humidifier_setpoint_precision = json_payload.at("value").get(); ++ humidifier_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +@@ -63048,7 +63755,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_dehumidifier_setpoint_prec + } + + +- uint8_t dehumidifier_setpoint_precision = {}; ++ int8_t dehumidifier_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -63061,7 +63768,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_dehumidifier_setpoint_prec + return; + } + // Start parsing value +- dehumidifier_setpoint_precision = json_payload.at("value").get(); ++ dehumidifier_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +@@ -63436,7 +64143,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_auto_setpoint_precision_at + } + + +- uint8_t auto_setpoint_precision = {}; ++ int8_t auto_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -63449,7 +64156,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_auto_setpoint_precision_at + return; + } + // Start parsing value +- auto_setpoint_precision = json_payload.at("value").get(); ++ auto_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp +index a738479fb0..64fc94ecbf 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp +@@ -160,21 +160,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("MainsVoltageMinThreshold") != jsn.end()) { + +- new_state.mains_voltage_min_threshold = jsn.at("MainsVoltageMinThreshold").get(); ++ new_state.mains_voltage_min_threshold = jsn.at("MainsVoltageMinThreshold").get(); + + new_updated_state.mains_voltage_min_threshold = true; + } + + if (jsn.find("MainsVoltageMaxThreshold") != jsn.end()) { + +- new_state.mains_voltage_max_threshold = jsn.at("MainsVoltageMaxThreshold").get(); ++ new_state.mains_voltage_max_threshold = jsn.at("MainsVoltageMaxThreshold").get(); + + new_updated_state.mains_voltage_max_threshold = true; + } + + if (jsn.find("MainsVoltageDwellTripPoint") != jsn.end()) { + +- new_state.mains_voltage_dwell_trip_point = jsn.at("MainsVoltageDwellTripPoint").get(); ++ new_state.mains_voltage_dwell_trip_point = jsn.at("MainsVoltageDwellTripPoint").get(); + + new_updated_state.mains_voltage_dwell_trip_point = true; + } +@@ -203,21 +203,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("BatteryAHrRating") != jsn.end()) { + +- new_state.batterya_hr_rating = jsn.at("BatteryAHrRating").get(); ++ new_state.batterya_hr_rating = jsn.at("BatteryAHrRating").get(); + + new_updated_state.batterya_hr_rating = true; + } + + if (jsn.find("BatteryQuantity") != jsn.end()) { + +- new_state.battery_quantity = jsn.at("BatteryQuantity").get(); ++ new_state.battery_quantity = jsn.at("BatteryQuantity").get(); + + new_updated_state.battery_quantity = true; + } + + if (jsn.find("BatteryRatedVoltage") != jsn.end()) { + +- new_state.battery_rated_voltage = jsn.at("BatteryRatedVoltage").get(); ++ new_state.battery_rated_voltage = jsn.at("BatteryRatedVoltage").get(); + + new_updated_state.battery_rated_voltage = true; + } +@@ -231,56 +231,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("BatteryVoltageMinThreshold") != jsn.end()) { + +- new_state.battery_voltage_min_threshold = jsn.at("BatteryVoltageMinThreshold").get(); ++ new_state.battery_voltage_min_threshold = jsn.at("BatteryVoltageMinThreshold").get(); + + new_updated_state.battery_voltage_min_threshold = true; + } + + if (jsn.find("BatteryVoltageThreshold1") != jsn.end()) { + +- new_state.battery_voltage_threshold1 = jsn.at("BatteryVoltageThreshold1").get(); ++ new_state.battery_voltage_threshold1 = jsn.at("BatteryVoltageThreshold1").get(); + + new_updated_state.battery_voltage_threshold1 = true; + } + + if (jsn.find("BatteryVoltageThreshold2") != jsn.end()) { + +- new_state.battery_voltage_threshold2 = jsn.at("BatteryVoltageThreshold2").get(); ++ new_state.battery_voltage_threshold2 = jsn.at("BatteryVoltageThreshold2").get(); + + new_updated_state.battery_voltage_threshold2 = true; + } + + if (jsn.find("BatteryVoltageThreshold3") != jsn.end()) { + +- new_state.battery_voltage_threshold3 = jsn.at("BatteryVoltageThreshold3").get(); ++ new_state.battery_voltage_threshold3 = jsn.at("BatteryVoltageThreshold3").get(); + + new_updated_state.battery_voltage_threshold3 = true; + } + + if (jsn.find("BatteryPercentageMinThreshold") != jsn.end()) { + +- new_state.battery_percentage_min_threshold = jsn.at("BatteryPercentageMinThreshold").get(); ++ new_state.battery_percentage_min_threshold = jsn.at("BatteryPercentageMinThreshold").get(); + + new_updated_state.battery_percentage_min_threshold = true; + } + + if (jsn.find("BatteryPercentageThreshold1") != jsn.end()) { + +- new_state.battery_percentage_threshold1 = jsn.at("BatteryPercentageThreshold1").get(); ++ new_state.battery_percentage_threshold1 = jsn.at("BatteryPercentageThreshold1").get(); + + new_updated_state.battery_percentage_threshold1 = true; + } + + if (jsn.find("BatteryPercentageThreshold2") != jsn.end()) { + +- new_state.battery_percentage_threshold2 = jsn.at("BatteryPercentageThreshold2").get(); ++ new_state.battery_percentage_threshold2 = jsn.at("BatteryPercentageThreshold2").get(); + + new_updated_state.battery_percentage_threshold2 = true; + } + + if (jsn.find("BatteryPercentageThreshold3") != jsn.end()) { + +- new_state.battery_percentage_threshold3 = jsn.at("BatteryPercentageThreshold3").get(); ++ new_state.battery_percentage_threshold3 = jsn.at("BatteryPercentageThreshold3").get(); + + new_updated_state.battery_percentage_threshold3 = true; + } +@@ -309,21 +309,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery2AHrRating") != jsn.end()) { + +- new_state.battery2a_hr_rating = jsn.at("Battery2AHrRating").get(); ++ new_state.battery2a_hr_rating = jsn.at("Battery2AHrRating").get(); + + new_updated_state.battery2a_hr_rating = true; + } + + if (jsn.find("Battery2Quantity") != jsn.end()) { + +- new_state.battery2_quantity = jsn.at("Battery2Quantity").get(); ++ new_state.battery2_quantity = jsn.at("Battery2Quantity").get(); + + new_updated_state.battery2_quantity = true; + } + + if (jsn.find("Battery2RatedVoltage") != jsn.end()) { + +- new_state.battery2_rated_voltage = jsn.at("Battery2RatedVoltage").get(); ++ new_state.battery2_rated_voltage = jsn.at("Battery2RatedVoltage").get(); + + new_updated_state.battery2_rated_voltage = true; + } +@@ -337,56 +337,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery2VoltageMinThreshold") != jsn.end()) { + +- new_state.battery2_voltage_min_threshold = jsn.at("Battery2VoltageMinThreshold").get(); ++ new_state.battery2_voltage_min_threshold = jsn.at("Battery2VoltageMinThreshold").get(); + + new_updated_state.battery2_voltage_min_threshold = true; + } + + if (jsn.find("Battery2VoltageThreshold1") != jsn.end()) { + +- new_state.battery2_voltage_threshold1 = jsn.at("Battery2VoltageThreshold1").get(); ++ new_state.battery2_voltage_threshold1 = jsn.at("Battery2VoltageThreshold1").get(); + + new_updated_state.battery2_voltage_threshold1 = true; + } + + if (jsn.find("Battery2VoltageThreshold2") != jsn.end()) { + +- new_state.battery2_voltage_threshold2 = jsn.at("Battery2VoltageThreshold2").get(); ++ new_state.battery2_voltage_threshold2 = jsn.at("Battery2VoltageThreshold2").get(); + + new_updated_state.battery2_voltage_threshold2 = true; + } + + if (jsn.find("Battery2VoltageThreshold3") != jsn.end()) { + +- new_state.battery2_voltage_threshold3 = jsn.at("Battery2VoltageThreshold3").get(); ++ new_state.battery2_voltage_threshold3 = jsn.at("Battery2VoltageThreshold3").get(); + + new_updated_state.battery2_voltage_threshold3 = true; + } + + if (jsn.find("Battery2PercentageMinThreshold") != jsn.end()) { + +- new_state.battery2_percentage_min_threshold = jsn.at("Battery2PercentageMinThreshold").get(); ++ new_state.battery2_percentage_min_threshold = jsn.at("Battery2PercentageMinThreshold").get(); + + new_updated_state.battery2_percentage_min_threshold = true; + } + + if (jsn.find("Battery2PercentageThreshold1") != jsn.end()) { + +- new_state.battery2_percentage_threshold1 = jsn.at("Battery2PercentageThreshold1").get(); ++ new_state.battery2_percentage_threshold1 = jsn.at("Battery2PercentageThreshold1").get(); + + new_updated_state.battery2_percentage_threshold1 = true; + } + + if (jsn.find("Battery2PercentageThreshold2") != jsn.end()) { + +- new_state.battery2_percentage_threshold2 = jsn.at("Battery2PercentageThreshold2").get(); ++ new_state.battery2_percentage_threshold2 = jsn.at("Battery2PercentageThreshold2").get(); + + new_updated_state.battery2_percentage_threshold2 = true; + } + + if (jsn.find("Battery2PercentageThreshold3") != jsn.end()) { + +- new_state.battery2_percentage_threshold3 = jsn.at("Battery2PercentageThreshold3").get(); ++ new_state.battery2_percentage_threshold3 = jsn.at("Battery2PercentageThreshold3").get(); + + new_updated_state.battery2_percentage_threshold3 = true; + } +@@ -415,21 +415,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery3AHrRating") != jsn.end()) { + +- new_state.battery3a_hr_rating = jsn.at("Battery3AHrRating").get(); ++ new_state.battery3a_hr_rating = jsn.at("Battery3AHrRating").get(); + + new_updated_state.battery3a_hr_rating = true; + } + + if (jsn.find("Battery3Quantity") != jsn.end()) { + +- new_state.battery3_quantity = jsn.at("Battery3Quantity").get(); ++ new_state.battery3_quantity = jsn.at("Battery3Quantity").get(); + + new_updated_state.battery3_quantity = true; + } + + if (jsn.find("Battery3RatedVoltage") != jsn.end()) { + +- new_state.battery3_rated_voltage = jsn.at("Battery3RatedVoltage").get(); ++ new_state.battery3_rated_voltage = jsn.at("Battery3RatedVoltage").get(); + + new_updated_state.battery3_rated_voltage = true; + } +@@ -443,56 +443,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery3VoltageMinThreshold") != jsn.end()) { + +- new_state.battery3_voltage_min_threshold = jsn.at("Battery3VoltageMinThreshold").get(); ++ new_state.battery3_voltage_min_threshold = jsn.at("Battery3VoltageMinThreshold").get(); + + new_updated_state.battery3_voltage_min_threshold = true; + } + + if (jsn.find("Battery3VoltageThreshold1") != jsn.end()) { + +- new_state.battery3_voltage_threshold1 = jsn.at("Battery3VoltageThreshold1").get(); ++ new_state.battery3_voltage_threshold1 = jsn.at("Battery3VoltageThreshold1").get(); + + new_updated_state.battery3_voltage_threshold1 = true; + } + + if (jsn.find("Battery3VoltageThreshold2") != jsn.end()) { + +- new_state.battery3_voltage_threshold2 = jsn.at("Battery3VoltageThreshold2").get(); ++ new_state.battery3_voltage_threshold2 = jsn.at("Battery3VoltageThreshold2").get(); + + new_updated_state.battery3_voltage_threshold2 = true; + } + + if (jsn.find("Battery3VoltageThreshold3") != jsn.end()) { + +- new_state.battery3_voltage_threshold3 = jsn.at("Battery3VoltageThreshold3").get(); ++ new_state.battery3_voltage_threshold3 = jsn.at("Battery3VoltageThreshold3").get(); + + new_updated_state.battery3_voltage_threshold3 = true; + } + + if (jsn.find("Battery3PercentageMinThreshold") != jsn.end()) { + +- new_state.battery3_percentage_min_threshold = jsn.at("Battery3PercentageMinThreshold").get(); ++ new_state.battery3_percentage_min_threshold = jsn.at("Battery3PercentageMinThreshold").get(); + + new_updated_state.battery3_percentage_min_threshold = true; + } + + if (jsn.find("Battery3PercentageThreshold1") != jsn.end()) { + +- new_state.battery3_percentage_threshold1 = jsn.at("Battery3PercentageThreshold1").get(); ++ new_state.battery3_percentage_threshold1 = jsn.at("Battery3PercentageThreshold1").get(); + + new_updated_state.battery3_percentage_threshold1 = true; + } + + if (jsn.find("Battery3PercentageThreshold2") != jsn.end()) { + +- new_state.battery3_percentage_threshold2 = jsn.at("Battery3PercentageThreshold2").get(); ++ new_state.battery3_percentage_threshold2 = jsn.at("Battery3PercentageThreshold2").get(); + + new_updated_state.battery3_percentage_threshold2 = true; + } + + if (jsn.find("Battery3PercentageThreshold3") != jsn.end()) { + +- new_state.battery3_percentage_threshold3 = jsn.at("Battery3PercentageThreshold3").get(); ++ new_state.battery3_percentage_threshold3 = jsn.at("Battery3PercentageThreshold3").get(); + + new_updated_state.battery3_percentage_threshold3 = true; + } +@@ -536,14 +536,14 @@ void uic_mqtt_dotdot_parse_device_temperature_configuration_write_attributes( + + if (jsn.find("LowTempDwellTripPoint") != jsn.end()) { + +- new_state.low_temp_dwell_trip_point = jsn.at("LowTempDwellTripPoint").get(); ++ new_state.low_temp_dwell_trip_point = jsn.at("LowTempDwellTripPoint").get(); + + new_updated_state.low_temp_dwell_trip_point = true; + } + + if (jsn.find("HighTempDwellTripPoint") != jsn.end()) { + +- new_state.high_temp_dwell_trip_point = jsn.at("HighTempDwellTripPoint").get(); ++ new_state.high_temp_dwell_trip_point = jsn.at("HighTempDwellTripPoint").get(); + + new_updated_state.high_temp_dwell_trip_point = true; + } +@@ -577,7 +577,7 @@ std::string get_json_payload_for_identify_identify_command( + + void uic_mqtt_dotdot_parse_identify_identify( + nlohmann::json &jsn, +- uint16_t &identify_time ++ int16_t &identify_time + + ) { + +@@ -586,7 +586,7 @@ void uic_mqtt_dotdot_parse_identify_identify( + return; + } + +- identify_time = jsn.at("IdentifyTime").get< uint16_t >(); ++ identify_time = jsn.at("IdentifyTime").get< int16_t >(); + } + + +@@ -615,7 +615,7 @@ std::string get_json_payload_for_identify_identify_query_response_command( + + void uic_mqtt_dotdot_parse_identify_identify_query_response( + nlohmann::json &jsn, +- uint16_t &timeout ++ int16_t &timeout + + ) { + +@@ -624,7 +624,7 @@ void uic_mqtt_dotdot_parse_identify_identify_query_response( + return; + } + +- timeout = jsn.at("Timeout").get< uint16_t >(); ++ timeout = jsn.at("Timeout").get< int16_t >(); + } + + +@@ -743,7 +743,7 @@ void uic_mqtt_dotdot_parse_identify_write_attributes( + + if (jsn.find("IdentifyTime") != jsn.end()) { + +- new_state.identify_time = jsn.at("IdentifyTime").get(); ++ new_state.identify_time = jsn.at("IdentifyTime").get(); + + new_updated_state.identify_time = true; + } +@@ -781,7 +781,7 @@ std::string get_json_payload_for_groups_add_group_command( + + void uic_mqtt_dotdot_parse_groups_add_group( + nlohmann::json &jsn, +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -792,7 +792,7 @@ void uic_mqtt_dotdot_parse_groups_add_group( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -844,7 +844,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id ++ int16_t &group_id + + ) { + +@@ -864,7 +864,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + } + + +@@ -893,7 +893,7 @@ std::string get_json_payload_for_groups_view_group_command( + + void uic_mqtt_dotdot_parse_groups_view_group( + nlohmann::json &jsn, +- uint16_t &group_id ++ int16_t &group_id + + ) { + +@@ -902,7 +902,7 @@ void uic_mqtt_dotdot_parse_groups_view_group( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + } + + +@@ -952,7 +952,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -974,7 +974,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -995,7 +995,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + nlohmann::json json_payload; + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["GroupList"] = std::vector< uint16_t >( ++ json_payload["GroupList"] = std::vector< int16_t >( + fields->group_list, + fields->group_list + fields->group_list_count); + +@@ -1011,7 +1011,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + + void uic_mqtt_dotdot_parse_groups_get_group_membership( + nlohmann::json &jsn, +- std::vector &group_list ++ std::vector &group_list + + ) { + +@@ -1020,7 +1020,7 @@ void uic_mqtt_dotdot_parse_groups_get_group_membership( + return; + } + +- group_list = jsn.at("GroupList").get< std::vector< uint16_t >>(); ++ group_list = jsn.at("GroupList").get< std::vector< int16_t >>(); + } + + +@@ -1039,7 +1039,7 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + json_payload["Capacity"] = nlohmann::json(fields->capacity); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["GroupList"] = std::vector< uint16_t >( ++ json_payload["GroupList"] = std::vector< int16_t >( + fields->group_list, + fields->group_list + fields->group_list_count); + +@@ -1055,9 +1055,9 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + + void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + nlohmann::json &jsn, +- uint8_t &capacity, ++ int8_t &capacity, + +- std::vector &group_list ++ std::vector &group_list + + ) { + +@@ -1066,13 +1066,13 @@ void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + return; + } + +- capacity = jsn.at("Capacity").get< uint8_t >(); ++ capacity = jsn.at("Capacity").get< int8_t >(); + if (jsn.at("GroupList").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- group_list = jsn.at("GroupList").get< std::vector< uint16_t >>(); ++ group_list = jsn.at("GroupList").get< std::vector< int16_t >>(); + } + + +@@ -1101,7 +1101,7 @@ std::string get_json_payload_for_groups_remove_group_command( + + void uic_mqtt_dotdot_parse_groups_remove_group( + nlohmann::json &jsn, +- uint16_t &group_id ++ int16_t &group_id + + ) { + +@@ -1110,7 +1110,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + } + + +@@ -1156,7 +1156,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id ++ int16_t &group_id + + ) { + +@@ -1176,7 +1176,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + } + + +@@ -1228,7 +1228,7 @@ std::string get_json_payload_for_groups_add_group_if_identifying_command( + + void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + nlohmann::json &jsn, +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -1239,7 +1239,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + return; + } + +- group_id = jsn.at("GroupId").get< uint16_t >(); ++ group_id = jsn.at("GroupId").get< int16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1312,17 +1312,17 @@ std::string get_json_payload_for_scenes_add_scene_command( + + void uic_mqtt_dotdot_parse_scenes_add_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + + std::vector &extension_field_sets, + +- uint8_t &transition_time100ms ++ int8_t &transition_time100ms + + ) { + +@@ -1331,19 +1331,19 @@ void uic_mqtt_dotdot_parse_scenes_add_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1375,7 +1375,7 @@ void uic_mqtt_dotdot_parse_scenes_add_scene( + return; + } + +- transition_time100ms = jsn.at("TransitionTime100ms").get< uint8_t >(); ++ transition_time100ms = jsn.at("TransitionTime100ms").get< int8_t >(); + } + + +@@ -1425,9 +1425,9 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1447,13 +1447,13 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -1486,9 +1486,9 @@ std::string get_json_payload_for_scenes_view_scene_command( + + void uic_mqtt_dotdot_parse_scenes_view_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1497,13 +1497,13 @@ void uic_mqtt_dotdot_parse_scenes_view_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -1567,11 +1567,11 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -1595,19 +1595,19 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1666,9 +1666,9 @@ std::string get_json_payload_for_scenes_remove_scene_command( + + void uic_mqtt_dotdot_parse_scenes_remove_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1677,13 +1677,13 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -1733,9 +1733,9 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1755,13 +1755,13 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -1790,7 +1790,7 @@ std::string get_json_payload_for_scenes_remove_all_scenes_command( + + void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + nlohmann::json &jsn, +- uint16_t &groupid ++ uint8_t * &groupid + + ) { + +@@ -1799,7 +1799,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + } + + +@@ -1845,7 +1845,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid ++ uint8_t * &groupid + + ) { + +@@ -1865,7 +1865,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + } + + +@@ -1898,9 +1898,9 @@ std::string get_json_payload_for_scenes_store_scene_command( + + void uic_mqtt_dotdot_parse_scenes_store_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1909,13 +1909,13 @@ void uic_mqtt_dotdot_parse_scenes_store_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -1965,9 +1965,9 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -1987,13 +1987,13 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -2030,11 +2030,11 @@ std::string get_json_payload_for_scenes_recall_scene_command( + + void uic_mqtt_dotdot_parse_scenes_recall_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time ++ int16_t &transition_time + + ) { + +@@ -2043,19 +2043,19 @@ void uic_mqtt_dotdot_parse_scenes_recall_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + } + + +@@ -2084,7 +2084,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_command( + + void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + nlohmann::json &jsn, +- uint16_t &groupid ++ uint8_t * &groupid + + ) { + +@@ -2093,7 +2093,7 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + } + + +@@ -2131,7 +2131,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_response_command( + json_payload["GroupID"] = nlohmann::json(fields->groupid); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["SceneList"] = std::vector< uint8_t >( ++ json_payload["SceneList"] = std::vector< int8_t >( + fields->scene_list, + fields->scene_list + fields->scene_list_count); + +@@ -2149,11 +2149,11 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t &capacity, ++ int8_t &capacity, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- std::vector &scene_list ++ std::vector &scene_list + + ) { + +@@ -2173,19 +2173,19 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + return; + } + +- capacity = jsn.at("Capacity").get< uint8_t >(); ++ capacity = jsn.at("Capacity").get< int8_t >(); + if (jsn.at("GroupID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneList").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_list = jsn.at("SceneList").get< std::vector< uint8_t >>(); ++ scene_list = jsn.at("SceneList").get< std::vector< int8_t >>(); + } + + +@@ -2232,11 +2232,11 @@ std::string get_json_payload_for_scenes_enhanced_add_scene_command( + + void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -2249,19 +2249,19 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -2337,9 +2337,9 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -2359,13 +2359,13 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -2398,9 +2398,9 @@ std::string get_json_payload_for_scenes_enhanced_view_scene_command( + + void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ) { + +@@ -2409,13 +2409,13 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + } + + +@@ -2479,11 +2479,11 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -2507,19 +2507,19 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint16_t >(); ++ groupid = jsn.at("GroupID").get< uint8_t * >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< uint8_t >(); ++ sceneid = jsn.at("SceneID").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -2594,13 +2594,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + nlohmann::json &jsn, + uint8_t &mode, + +- uint16_t &group_identifier_from, ++ uint8_t * &group_identifier_from, + +- uint8_t &scene_identifier_from, ++ int8_t &scene_identifier_from, + +- uint16_t &group_identifier_to, ++ uint8_t * &group_identifier_to, + +- uint8_t &scene_identifier_to ++ int8_t &scene_identifier_to + + ) { + +@@ -2614,25 +2614,25 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + return; + } + +- group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint16_t >(); ++ group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint8_t * >(); + if (jsn.at("SceneIdentifierFrom").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_from = jsn.at("SceneIdentifierFrom").get< uint8_t >(); ++ scene_identifier_from = jsn.at("SceneIdentifierFrom").get< int8_t >(); + if (jsn.at("GroupIdentifierTo").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- group_identifier_to = jsn.at("GroupIdentifierTo").get< uint16_t >(); ++ group_identifier_to = jsn.at("GroupIdentifierTo").get< uint8_t * >(); + if (jsn.at("SceneIdentifierTo").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_to = jsn.at("SceneIdentifierTo").get< uint8_t >(); ++ scene_identifier_to = jsn.at("SceneIdentifierTo").get< int8_t >(); + } + + +@@ -2682,9 +2682,9 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &group_identifier_from, ++ uint8_t * &group_identifier_from, + +- uint8_t &scene_identifier_from ++ int8_t &scene_identifier_from + + ) { + +@@ -2704,13 +2704,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + return; + } + +- group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint16_t >(); ++ group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint8_t * >(); + if (jsn.at("SceneIdentifierFrom").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_from = jsn.at("SceneIdentifierFrom").get< uint8_t >(); ++ scene_identifier_from = jsn.at("SceneIdentifierFrom").get< int8_t >(); + } + + +@@ -2829,7 +2829,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + nlohmann::json &jsn, + OffWithEffectEffectIdentifier &effect_identifier, + +- uint8_t &effect_variant ++ int8_t &effect_variant + + ) { + +@@ -2849,7 +2849,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + return; + } + +- effect_variant = jsn.at("EffectVariant").get< uint8_t >(); ++ effect_variant = jsn.at("EffectVariant").get< int8_t >(); + } + + +@@ -2909,9 +2909,9 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + nlohmann::json &jsn, + uint8_t &on_off_control, + +- uint16_t &on_time, ++ int16_t &on_time, + +- uint16_t &off_wait_time ++ int16_t &off_wait_time + + ) { + +@@ -2925,13 +2925,13 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + return; + } + +- on_time = jsn.at("OnTime").get< uint16_t >(); ++ on_time = jsn.at("OnTime").get< int16_t >(); + if (jsn.at("OffWaitTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- off_wait_time = jsn.at("OffWaitTime").get< uint16_t >(); ++ off_wait_time = jsn.at("OffWaitTime").get< int16_t >(); + } + + +@@ -2949,14 +2949,14 @@ void uic_mqtt_dotdot_parse_on_off_write_attributes( + + if (jsn.find("OnTime") != jsn.end()) { + +- new_state.on_time = jsn.at("OnTime").get(); ++ new_state.on_time = jsn.at("OnTime").get(); + + new_updated_state.on_time = true; + } + + if (jsn.find("OffWaitTime") != jsn.end()) { + +- new_state.off_wait_time = jsn.at("OffWaitTime").get(); ++ new_state.off_wait_time = jsn.at("OffWaitTime").get(); + + new_updated_state.off_wait_time = true; + } +@@ -3021,9 +3021,9 @@ std::string get_json_payload_for_level_move_to_level_command( + + void uic_mqtt_dotdot_parse_level_move_to_level( + nlohmann::json &jsn, +- uint8_t &level, ++ int8_t &level, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -3036,13 +3036,13 @@ void uic_mqtt_dotdot_parse_level_move_to_level( + return; + } + +- level = jsn.at("Level").get< uint8_t >(); ++ level = jsn.at("Level").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3110,7 +3110,7 @@ void uic_mqtt_dotdot_parse_level_move( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -3134,7 +3134,7 @@ void uic_mqtt_dotdot_parse_level_move( + return; + } + +- rate = jsn.at("Rate").get< uint8_t >(); ++ rate = jsn.at("Rate").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3206,9 +3206,9 @@ void uic_mqtt_dotdot_parse_level_step( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -3232,13 +3232,13 @@ void uic_mqtt_dotdot_parse_level_step( + return; + } + +- step_size = jsn.at("StepSize").get< uint8_t >(); ++ step_size = jsn.at("StepSize").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3345,9 +3345,9 @@ std::string get_json_payload_for_level_move_to_level_with_on_off_command( + + void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + nlohmann::json &jsn, +- uint8_t &level, ++ int8_t &level, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -3360,13 +3360,13 @@ void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + return; + } + +- level = jsn.at("Level").get< uint8_t >(); ++ level = jsn.at("Level").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3434,7 +3434,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -3458,7 +3458,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + return; + } + +- rate = jsn.at("Rate").get< uint8_t >(); ++ rate = jsn.at("Rate").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3530,9 +3530,9 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -3556,13 +3556,13 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + return; + } + +- step_size = jsn.at("StepSize").get< uint8_t >(); ++ step_size = jsn.at("StepSize").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3653,7 +3653,7 @@ std::string get_json_payload_for_level_move_to_closest_frequency_command( + + void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + nlohmann::json &jsn, +- uint16_t &frequency ++ int16_t &frequency + + ) { + +@@ -3662,7 +3662,7 @@ void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + return; + } + +- frequency = jsn.at("Frequency").get< uint16_t >(); ++ frequency = jsn.at("Frequency").get< int16_t >(); + } + + +@@ -3687,42 +3687,42 @@ void uic_mqtt_dotdot_parse_level_write_attributes( + + if (jsn.find("OnOffTransitionTime") != jsn.end()) { + +- new_state.on_off_transition_time = jsn.at("OnOffTransitionTime").get(); ++ new_state.on_off_transition_time = jsn.at("OnOffTransitionTime").get(); + + new_updated_state.on_off_transition_time = true; + } + + if (jsn.find("OnLevel") != jsn.end()) { + +- new_state.on_level = jsn.at("OnLevel").get(); ++ new_state.on_level = jsn.at("OnLevel").get(); + + new_updated_state.on_level = true; + } + + if (jsn.find("OnTransitionTime") != jsn.end()) { + +- new_state.on_transition_time = jsn.at("OnTransitionTime").get(); ++ new_state.on_transition_time = jsn.at("OnTransitionTime").get(); + + new_updated_state.on_transition_time = true; + } + + if (jsn.find("OffTransitionTime") != jsn.end()) { + +- new_state.off_transition_time = jsn.at("OffTransitionTime").get(); ++ new_state.off_transition_time = jsn.at("OffTransitionTime").get(); + + new_updated_state.off_transition_time = true; + } + + if (jsn.find("DefaultMoveRate") != jsn.end()) { + +- new_state.default_move_rate = jsn.at("DefaultMoveRate").get(); ++ new_state.default_move_rate = jsn.at("DefaultMoveRate").get(); + + new_updated_state.default_move_rate = true; + } + + if (jsn.find("StartUpCurrentLevel") != jsn.end()) { + +- new_state.start_up_current_level = jsn.at("StartUpCurrentLevel").get(); ++ new_state.start_up_current_level = jsn.at("StartUpCurrentLevel").get(); + + new_updated_state.start_up_current_level = true; + } +@@ -3773,7 +3773,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint16_t &cluster_identifier ++ uint8_t &cluster_identifier + + ) { + +@@ -3793,7 +3793,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); + } + + +@@ -3839,7 +3839,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint16_t &cluster_identifier ++ uint8_t &cluster_identifier + + ) { + +@@ -3859,7 +3859,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); + } + + +@@ -3945,9 +3945,9 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + + uint8_t &alarm_code, + +- uint16_t &cluster_identifier, ++ uint8_t &cluster_identifier, + +- uint32_t &time_stamp ++ int32_t &time_stamp + + ) { + +@@ -3978,13 +3978,13 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); + if (jsn.at("TimeStamp").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- time_stamp = jsn.at("TimeStamp").get< uint32_t >(); ++ time_stamp = jsn.at("TimeStamp").get< int32_t >(); + } + + +@@ -4056,7 +4056,7 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("Time") != jsn.end()) { + +- new_state.time = jsn.at("Time").get(); ++ new_state.time = jsn.at("Time").get(); + + new_updated_state.time = true; + } +@@ -4077,14 +4077,14 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("DstStart") != jsn.end()) { + +- new_state.dst_start = jsn.at("DstStart").get(); ++ new_state.dst_start = jsn.at("DstStart").get(); + + new_updated_state.dst_start = true; + } + + if (jsn.find("DstEnd") != jsn.end()) { + +- new_state.dst_end = jsn.at("DstEnd").get(); ++ new_state.dst_end = jsn.at("DstEnd").get(); + + new_updated_state.dst_end = true; + } +@@ -4098,7 +4098,7 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("ValidUntilTime") != jsn.end()) { + +- new_state.valid_until_time = jsn.at("ValidUntilTime").get(); ++ new_state.valid_until_time = jsn.at("ValidUntilTime").get(); + + new_updated_state.valid_until_time = true; + } +@@ -4157,7 +4157,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + nlohmann::json &jsn, + bool &start_fast_polling, + +- uint16_t &fast_poll_timeout ++ int16_t &fast_poll_timeout + + ) { + +@@ -4172,7 +4172,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + return; + } + +- fast_poll_timeout = jsn.at("FastPollTimeout").get< uint16_t >(); ++ fast_poll_timeout = jsn.at("FastPollTimeout").get< int16_t >(); + } + + +@@ -4220,7 +4220,7 @@ std::string get_json_payload_for_poll_control_set_long_poll_interval_command( + + void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + nlohmann::json &jsn, +- uint32_t &new_long_poll_interval ++ int32_t &new_long_poll_interval + + ) { + +@@ -4229,7 +4229,7 @@ void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + return; + } + +- new_long_poll_interval = jsn.at("NewLongPollInterval").get< uint32_t >(); ++ new_long_poll_interval = jsn.at("NewLongPollInterval").get< int32_t >(); + } + + +@@ -4258,7 +4258,7 @@ std::string get_json_payload_for_poll_control_set_short_poll_interval_command( + + void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + nlohmann::json &jsn, +- uint16_t &new_short_poll_interval ++ int16_t &new_short_poll_interval + + ) { + +@@ -4267,7 +4267,7 @@ void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + return; + } + +- new_short_poll_interval = jsn.at("NewShortPollInterval").get< uint16_t >(); ++ new_short_poll_interval = jsn.at("NewShortPollInterval").get< int16_t >(); + } + + +@@ -4285,14 +4285,14 @@ void uic_mqtt_dotdot_parse_poll_control_write_attributes( + + if (jsn.find("CheckInInterval") != jsn.end()) { + +- new_state.check_in_interval = jsn.at("CheckInInterval").get(); ++ new_state.check_in_interval = jsn.at("CheckInInterval").get(); + + new_updated_state.check_in_interval = true; + } + + if (jsn.find("FastPollTimeout") != jsn.end()) { + +- new_state.fast_poll_timeout = jsn.at("FastPollTimeout").get(); ++ new_state.fast_poll_timeout = jsn.at("FastPollTimeout").get(); + + new_updated_state.fast_poll_timeout = true; + } +@@ -4322,7 +4322,7 @@ void uic_mqtt_dotdot_parse_shade_configuration_write_attributes( + + if (jsn.find("ClosedLimit") != jsn.end()) { + +- new_state.closed_limit = jsn.at("ClosedLimit").get(); ++ new_state.closed_limit = jsn.at("ClosedLimit").get(); + + new_updated_state.closed_limit = true; + } +@@ -4651,7 +4651,7 @@ std::string get_json_payload_for_door_lock_unlock_with_timeout_command( + + void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + nlohmann::json &jsn, +- uint16_t &timeout_in_seconds, ++ int16_t &timeout_in_seconds, + + std::string &pin_or_rfid_code + +@@ -4662,7 +4662,7 @@ void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + return; + } + +- timeout_in_seconds = jsn.at("TimeoutInSeconds").get< uint16_t >(); ++ timeout_in_seconds = jsn.at("TimeoutInSeconds").get< int16_t >(); + if (jsn.at("PINOrRFIDCode").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4751,7 +4751,7 @@ std::string get_json_payload_for_door_lock_get_log_record_command( + + void uic_mqtt_dotdot_parse_door_lock_get_log_record( + nlohmann::json &jsn, +- uint16_t &log_index ++ int16_t &log_index + + ) { + +@@ -4760,7 +4760,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record( + return; + } + +- log_index = jsn.at("LogIndex").get< uint16_t >(); ++ log_index = jsn.at("LogIndex").get< int16_t >(); + } + + +@@ -4835,17 +4835,17 @@ std::string get_json_payload_for_door_lock_get_log_record_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + nlohmann::json &jsn, +- uint16_t &log_entryid, ++ int16_t &log_entryid, + +- uint32_t ×tamp, ++ int32_t ×tamp, + + GetLogRecordResponseEventType &event_type, + + DrlkOperEventSource &source_operation_event, + +- uint8_t &event_id_or_alarm_code, ++ int8_t &event_id_or_alarm_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin + +@@ -4868,13 +4868,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + return; + } + +- log_entryid = jsn.at("LogEntryID").get< uint16_t >(); ++ log_entryid = jsn.at("LogEntryID").get< int16_t >(); + if (jsn.at("Timestamp").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- timestamp = jsn.at("Timestamp").get< uint32_t >(); ++ timestamp = jsn.at("Timestamp").get< int32_t >(); + if (jsn.at("EventType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4890,13 +4890,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + return; + } + +- event_id_or_alarm_code = jsn.at("EventIDOrAlarmCode").get< uint8_t >(); ++ event_id_or_alarm_code = jsn.at("EventIDOrAlarmCode").get< int8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4965,7 +4965,7 @@ std::string get_json_payload_for_door_lock_set_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status, + +@@ -4992,7 +4992,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5091,7 +5091,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -5100,7 +5100,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -5163,7 +5163,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status, + +@@ -5190,7 +5190,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5235,7 +5235,7 @@ std::string get_json_payload_for_door_lock_clear_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -5244,7 +5244,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -5415,7 +5415,7 @@ std::string get_json_payload_for_door_lock_set_user_status_command( + + void uic_mqtt_dotdot_parse_door_lock_set_user_status( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status + +@@ -5432,7 +5432,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user_status( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5520,7 +5520,7 @@ std::string get_json_payload_for_door_lock_get_user_status_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_status( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -5529,7 +5529,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_status( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -5573,7 +5573,7 @@ std::string get_json_payload_for_door_lock_get_user_status_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status + +@@ -5590,7 +5590,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5650,19 +5650,19 @@ std::string get_json_payload_for_door_lock_set_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid, ++ uint8_t * &userid, + + uint8_t &days_mask, + +- uint8_t &start_hour, ++ int8_t &start_hour, + +- uint8_t &start_minute, ++ int8_t &start_minute, + +- uint8_t &end_hour, ++ int8_t &end_hour, + +- uint8_t &end_minute ++ int8_t &end_minute + + ) { + +@@ -5671,13 +5671,13 @@ void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("DaysMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5688,25 +5688,25 @@ void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + return; + } + +- start_hour = jsn.at("StartHour").get< uint8_t >(); ++ start_hour = jsn.at("StartHour").get< int8_t >(); + if (jsn.at("StartMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_minute = jsn.at("StartMinute").get< uint8_t >(); ++ start_minute = jsn.at("StartMinute").get< int8_t >(); + if (jsn.at("EndHour").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_hour = jsn.at("EndHour").get< uint8_t >(); ++ end_hour = jsn.at("EndHour").get< int8_t >(); + if (jsn.at("EndMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_minute = jsn.at("EndMinute").get< uint8_t >(); ++ end_minute = jsn.at("EndMinute").get< int8_t >(); + } + + +@@ -5793,9 +5793,9 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -5804,13 +5804,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -5880,21 +5880,21 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_response_command + + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ int8_t &scheduleid, + +- uint16_t &userid, ++ int16_t &userid, + + zclStatus &status, + + uint8_t &days_mask, + +- uint8_t &start_hour, ++ int8_t &start_hour, + +- uint8_t &start_minute, ++ int8_t &start_minute, + +- uint8_t &end_hour, ++ int8_t &end_hour, + +- uint8_t &end_minute ++ int8_t &end_minute + + ) { + +@@ -5909,13 +5909,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< int8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5931,25 +5931,25 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + return; + } + +- start_hour = jsn.at("StartHour").get< uint8_t >(); ++ start_hour = jsn.at("StartHour").get< int8_t >(); + if (jsn.at("StartMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_minute = jsn.at("StartMinute").get< uint8_t >(); ++ start_minute = jsn.at("StartMinute").get< int8_t >(); + if (jsn.at("EndHour").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_hour = jsn.at("EndHour").get< uint8_t >(); ++ end_hour = jsn.at("EndHour").get< int8_t >(); + if (jsn.at("EndMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_minute = jsn.at("EndMinute").get< uint8_t >(); ++ end_minute = jsn.at("EndMinute").get< int8_t >(); + } + + +@@ -5982,9 +5982,9 @@ std::string get_json_payload_for_door_lock_clear_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -5993,13 +5993,13 @@ void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -6094,13 +6094,13 @@ std::string get_json_payload_for_door_lock_set_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid, ++ uint8_t * &userid, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time ++ int32_t &local_end_time + + ) { + +@@ -6109,25 +6109,25 @@ void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("LocalStartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< int32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< int32_t >(); + } + + +@@ -6214,9 +6214,9 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -6225,13 +6225,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -6287,15 +6287,15 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_response_comman + + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ int8_t &scheduleid, + +- uint16_t &userid, ++ int16_t &userid, + + zclStatus &status, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time ++ int32_t &local_end_time + + ) { + +@@ -6310,13 +6310,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< int8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6327,13 +6327,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< int32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< int32_t >(); + } + + +@@ -6366,9 +6366,9 @@ std::string get_json_payload_for_door_lock_clear_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -6377,13 +6377,13 @@ void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -6489,11 +6489,11 @@ std::string get_json_payload_for_door_lock_set_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid, ++ uint8_t * &holiday_scheduleid, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time, ++ int32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -6510,19 +6510,19 @@ void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); + if (jsn.at("LocalStartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< int32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< int32_t >(); + if (jsn.at("OperatingModeDuringHoliday").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6610,7 +6610,7 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid ++ uint8_t * &holiday_scheduleid + + ) { + +@@ -6619,7 +6619,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); + } + + +@@ -6686,13 +6686,13 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_response_command + + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid, ++ int8_t &holiday_scheduleid, + + zclStatus &status, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time, ++ int32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -6715,7 +6715,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< int8_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6726,13 +6726,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< int32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< int32_t >(); + if (jsn.at("OperatingModeDuringHoliday").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6766,7 +6766,7 @@ std::string get_json_payload_for_door_lock_clear_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid ++ uint8_t * &holiday_scheduleid + + ) { + +@@ -6775,7 +6775,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); + } + + +@@ -6873,7 +6873,7 @@ std::string get_json_payload_for_door_lock_set_user_type_command( + + void uic_mqtt_dotdot_parse_door_lock_set_user_type( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkUserType &user_type + +@@ -6890,7 +6890,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user_type( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6978,7 +6978,7 @@ std::string get_json_payload_for_door_lock_get_user_type_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_type( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -6987,7 +6987,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_type( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -7031,7 +7031,7 @@ std::string get_json_payload_for_door_lock_get_user_type_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserType &user_type + +@@ -7048,7 +7048,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7116,7 +7116,7 @@ std::string get_json_payload_for_door_lock_set_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status, + +@@ -7143,7 +7143,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7242,7 +7242,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -7251,7 +7251,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -7314,7 +7314,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status, + +@@ -7341,7 +7341,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7386,7 +7386,7 @@ std::string get_json_payload_for_door_lock_clear_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ) { + +@@ -7395,7 +7395,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< uint8_t * >(); + } + + +@@ -7621,11 +7621,11 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + nlohmann::json &jsn, + DataOperationTypeEnum &operation_type, + +- uint16_t &user_index, ++ int16_t &user_index, + + std::string &user_name, + +- uint32_t &user_uniqueid, ++ int32_t &user_uniqueid, + + DrlkSettableUserStatus &user_status, + +@@ -7669,7 +7669,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + return; + } + +- user_index = jsn.at("UserIndex").get< uint16_t >(); ++ user_index = jsn.at("UserIndex").get< int16_t >(); + if (jsn.at("UserName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7681,7 +7681,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< uint32_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< int32_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7725,7 +7725,7 @@ std::string get_json_payload_for_door_lock_get_user_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user( + nlohmann::json &jsn, +- uint16_t &user_index ++ int16_t &user_index + + ) { + +@@ -7734,7 +7734,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user( + return; + } + +- user_index = jsn.at("UserIndex").get< uint16_t >(); ++ user_index = jsn.at("UserIndex").get< int16_t >(); + } + + +@@ -7782,7 +7782,7 @@ std::string get_json_payload_for_door_lock_clear_user_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_user( + nlohmann::json &jsn, +- uint16_t &user_index ++ int16_t &user_index + + ) { + +@@ -7791,7 +7791,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_user( + return; + } + +- user_index = jsn.at("UserIndex").get< uint16_t >(); ++ user_index = jsn.at("UserIndex").get< int16_t >(); + } + + +@@ -7866,11 +7866,11 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + + OperatingEventNotificationOperationEventCode &operation_event_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin, + +- uint32_t &local_time, ++ int32_t &local_time, + + std::string &data + +@@ -7903,7 +7903,7 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7915,7 +7915,7 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + return; + } + +- local_time = jsn.at("LocalTime").get< uint32_t >(); ++ local_time = jsn.at("LocalTime").get< int32_t >(); + if (jsn.at("Data").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8026,7 +8026,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventCode &program_event_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin, + +@@ -8034,7 +8034,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + DrlkUserStatus &user_status, + +- uint32_t &local_time, ++ int32_t &local_time, + + std::string &data + +@@ -8079,7 +8079,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + return; + } + +- userid = jsn.at("UserID").get< uint16_t >(); ++ userid = jsn.at("UserID").get< int16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8101,7 +8101,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + return; + } + +- local_time = jsn.at("LocalTime").get< uint32_t >(); ++ local_time = jsn.at("LocalTime").get< int32_t >(); + if (jsn.at("Data").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8195,7 +8195,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + + std::string &credential_data, + +- uint16_t &user_index, ++ int16_t &user_index, + + DrlkSettableUserStatus &user_status, + +@@ -8243,7 +8243,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + return; + } + +- user_index = jsn.at("UserIndex").get< uint16_t >(); ++ user_index = jsn.at("UserIndex").get< int16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8423,21 +8423,21 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("DoorOpenEvents") != jsn.end()) { + +- new_state.door_open_events = jsn.at("DoorOpenEvents").get(); ++ new_state.door_open_events = jsn.at("DoorOpenEvents").get(); + + new_updated_state.door_open_events = true; + } + + if (jsn.find("DoorClosedEvents") != jsn.end()) { + +- new_state.door_closed_events = jsn.at("DoorClosedEvents").get(); ++ new_state.door_closed_events = jsn.at("DoorClosedEvents").get(); + + new_updated_state.door_closed_events = true; + } + + if (jsn.find("OpenPeriod") != jsn.end()) { + +- new_state.open_period = jsn.at("OpenPeriod").get(); ++ new_state.open_period = jsn.at("OpenPeriod").get(); + + new_updated_state.open_period = true; + } +@@ -8458,21 +8458,21 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("LEDSettings") != jsn.end()) { + +- new_state.led_settings = jsn.at("LEDSettings").get(); ++ new_state.led_settings = jsn.at("LEDSettings").get(); + + new_updated_state.led_settings = true; + } + + if (jsn.find("AutoRelockTime") != jsn.end()) { + +- new_state.auto_relock_time = jsn.at("AutoRelockTime").get(); ++ new_state.auto_relock_time = jsn.at("AutoRelockTime").get(); + + new_updated_state.auto_relock_time = true; + } + + if (jsn.find("SoundVolume") != jsn.end()) { + +- new_state.sound_volume = jsn.at("SoundVolume").get(); ++ new_state.sound_volume = jsn.at("SoundVolume").get(); + + new_updated_state.sound_volume = true; + } +@@ -8529,14 +8529,14 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("WrongCodeEntryLimit") != jsn.end()) { + +- new_state.wrong_code_entry_limit = jsn.at("WrongCodeEntryLimit").get(); ++ new_state.wrong_code_entry_limit = jsn.at("WrongCodeEntryLimit").get(); + + new_updated_state.wrong_code_entry_limit = true; + } + + if (jsn.find("UserCodeTemporaryDisableTime") != jsn.end()) { + +- new_state.user_code_temporary_disable_time = jsn.at("UserCodeTemporaryDisableTime").get(); ++ new_state.user_code_temporary_disable_time = jsn.at("UserCodeTemporaryDisableTime").get(); + + new_updated_state.user_code_temporary_disable_time = true; + } +@@ -8557,7 +8557,7 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("ExpiringUserTimeout") != jsn.end()) { + +- new_state.expiring_user_timeout = jsn.at("ExpiringUserTimeout").get(); ++ new_state.expiring_user_timeout = jsn.at("ExpiringUserTimeout").get(); + + new_updated_state.expiring_user_timeout = true; + } +@@ -8704,7 +8704,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_value_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + nlohmann::json &jsn, +- uint16_t &lift_value ++ int16_t &lift_value + + ) { + +@@ -8713,7 +8713,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + return; + } + +- lift_value = jsn.at("LiftValue").get< uint16_t >(); ++ lift_value = jsn.at("LiftValue").get< int16_t >(); + } + + +@@ -8742,7 +8742,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_percentage_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + nlohmann::json &jsn, +- uint8_t &percentage_lift_value ++ int8_t &percentage_lift_value + + ) { + +@@ -8751,7 +8751,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + return; + } + +- percentage_lift_value = jsn.at("PercentageLiftValue").get< uint8_t >(); ++ percentage_lift_value = jsn.at("PercentageLiftValue").get< int8_t >(); + } + + +@@ -8780,7 +8780,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_value_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + nlohmann::json &jsn, +- uint16_t &tilt_value ++ int16_t &tilt_value + + ) { + +@@ -8789,7 +8789,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + return; + } + +- tilt_value = jsn.at("TiltValue").get< uint16_t >(); ++ tilt_value = jsn.at("TiltValue").get< int16_t >(); + } + + +@@ -8818,7 +8818,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_percentage_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + nlohmann::json &jsn, +- uint8_t &percentage_tilt_value ++ int8_t &percentage_tilt_value + + ) { + +@@ -8827,7 +8827,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + return; + } + +- percentage_tilt_value = jsn.at("PercentageTiltValue").get< uint8_t >(); ++ percentage_tilt_value = jsn.at("PercentageTiltValue").get< int8_t >(); + } + + +@@ -8845,21 +8845,21 @@ void uic_mqtt_dotdot_parse_window_covering_write_attributes( + + if (jsn.find("VelocityLift") != jsn.end()) { + +- new_state.velocity_lift = jsn.at("VelocityLift").get(); ++ new_state.velocity_lift = jsn.at("VelocityLift").get(); + + new_updated_state.velocity_lift = true; + } + + if (jsn.find("AccelerationTimeLift") != jsn.end()) { + +- new_state.acceleration_time_lift = jsn.at("AccelerationTimeLift").get(); ++ new_state.acceleration_time_lift = jsn.at("AccelerationTimeLift").get(); + + new_updated_state.acceleration_time_lift = true; + } + + if (jsn.find("DecelerationTimeLift") != jsn.end()) { + +- new_state.deceleration_time_lift = jsn.at("DecelerationTimeLift").get(); ++ new_state.deceleration_time_lift = jsn.at("DecelerationTimeLift").get(); + + new_updated_state.deceleration_time_lift = true; + } +@@ -8900,7 +8900,7 @@ std::string get_json_payload_for_barrier_control_go_to_percent_command( + + void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + nlohmann::json &jsn, +- uint8_t &percent_open ++ int8_t &percent_open + + ) { + +@@ -8909,7 +8909,7 @@ void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + return; + } + +- percent_open = jsn.at("PercentOpen").get< uint8_t >(); ++ percent_open = jsn.at("PercentOpen").get< int8_t >(); + } + + +@@ -8946,42 +8946,42 @@ void uic_mqtt_dotdot_parse_barrier_control_write_attributes( + + if (jsn.find("OpenEvents") != jsn.end()) { + +- new_state.open_events = jsn.at("OpenEvents").get(); ++ new_state.open_events = jsn.at("OpenEvents").get(); + + new_updated_state.open_events = true; + } + + if (jsn.find("CloseEvents") != jsn.end()) { + +- new_state.close_events = jsn.at("CloseEvents").get(); ++ new_state.close_events = jsn.at("CloseEvents").get(); + + new_updated_state.close_events = true; + } + + if (jsn.find("CommandOpenEvents") != jsn.end()) { + +- new_state.command_open_events = jsn.at("CommandOpenEvents").get(); ++ new_state.command_open_events = jsn.at("CommandOpenEvents").get(); + + new_updated_state.command_open_events = true; + } + + if (jsn.find("CommandCloseEvents") != jsn.end()) { + +- new_state.command_close_events = jsn.at("CommandCloseEvents").get(); ++ new_state.command_close_events = jsn.at("CommandCloseEvents").get(); + + new_updated_state.command_close_events = true; + } + + if (jsn.find("OpenPeriod") != jsn.end()) { + +- new_state.open_period = jsn.at("OpenPeriod").get(); ++ new_state.open_period = jsn.at("OpenPeriod").get(); + + new_updated_state.open_period = true; + } + + if (jsn.find("ClosePeriod") != jsn.end()) { + +- new_state.close_period = jsn.at("ClosePeriod").get(); ++ new_state.close_period = jsn.at("ClosePeriod").get(); + + new_updated_state.close_period = true; + } +@@ -9004,14 +9004,14 @@ void uic_mqtt_dotdot_parse_pump_configuration_and_control_write_attributes( + + if (jsn.find("LifetimeRunningHours") != jsn.end()) { + +- new_state.lifetime_running_hours = jsn.at("LifetimeRunningHours").get(); ++ new_state.lifetime_running_hours = jsn.at("LifetimeRunningHours").get(); + + new_updated_state.lifetime_running_hours = true; + } + + if (jsn.find("Power") != jsn.end()) { + +- new_state.power = jsn.at("Power").get(); ++ new_state.power = jsn.at("Power").get(); + + new_updated_state.power = true; + } +@@ -9383,17 +9383,17 @@ std::string get_json_payload_for_thermostat_get_relay_status_log_response_comman + + void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + nlohmann::json &jsn, +- uint16_t &time_of_day, ++ int16_t &time_of_day, + + uint8_t &relay_status, + + int16_t &local_temperature, + +- uint8_t &humidity_percentage, ++ int8_t &humidity_percentage, + + int16_t &set_point, + +- uint16_t &unread_entries ++ int16_t &unread_entries + + ) { + +@@ -9402,7 +9402,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- time_of_day = jsn.at("TimeOfDay").get< uint16_t >(); ++ time_of_day = jsn.at("TimeOfDay").get< int16_t >(); + if (jsn.at("RelayStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -9419,7 +9419,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- humidity_percentage = jsn.at("HumidityPercentage").get< uint8_t >(); ++ humidity_percentage = jsn.at("HumidityPercentage").get< int8_t >(); + if (jsn.at("SetPoint").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -9431,7 +9431,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- unread_entries = jsn.at("UnreadEntries").get< uint16_t >(); ++ unread_entries = jsn.at("UnreadEntries").get< int16_t >(); + } + + +@@ -9668,7 +9668,7 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("TemperatureSetpointHoldDuration") != jsn.end()) { + +- new_state.temperature_setpoint_hold_duration = jsn.at("TemperatureSetpointHoldDuration").get(); ++ new_state.temperature_setpoint_hold_duration = jsn.at("TemperatureSetpointHoldDuration").get(); + + new_updated_state.temperature_setpoint_hold_duration = true; + } +@@ -9682,21 +9682,21 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("OccupiedSetback") != jsn.end()) { + +- new_state.occupied_setback = jsn.at("OccupiedSetback").get(); ++ new_state.occupied_setback = jsn.at("OccupiedSetback").get(); + + new_updated_state.occupied_setback = true; + } + + if (jsn.find("UnoccupiedSetback") != jsn.end()) { + +- new_state.unoccupied_setback = jsn.at("UnoccupiedSetback").get(); ++ new_state.unoccupied_setback = jsn.at("UnoccupiedSetback").get(); + + new_updated_state.unoccupied_setback = true; + } + + if (jsn.find("EmergencyHeatDelta") != jsn.end()) { + +- new_state.emergency_heat_delta = jsn.at("EmergencyHeatDelta").get(); ++ new_state.emergency_heat_delta = jsn.at("EmergencyHeatDelta").get(); + + new_updated_state.emergency_heat_delta = true; + } +@@ -9718,7 +9718,7 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("ACCapacity") != jsn.end()) { + +- new_state.ac_capacity = jsn.at("ACCapacity").get(); ++ new_state.ac_capacity = jsn.at("ACCapacity").get(); + + new_updated_state.ac_capacity = true; + } +@@ -9854,7 +9854,7 @@ void uic_mqtt_dotdot_parse_dehumidification_control_write_attributes( + + if (jsn.find("RHDehumidificationSetpoint") != jsn.end()) { + +- new_state.rh_dehumidification_setpoint = jsn.at("RHDehumidificationSetpoint").get(); ++ new_state.rh_dehumidification_setpoint = jsn.at("RHDehumidificationSetpoint").get(); + + new_updated_state.rh_dehumidification_setpoint = true; + } +@@ -9891,14 +9891,14 @@ void uic_mqtt_dotdot_parse_dehumidification_control_write_attributes( + + if (jsn.find("DehumidificationHysteresis") != jsn.end()) { + +- new_state.dehumidification_hysteresis = jsn.at("DehumidificationHysteresis").get(); ++ new_state.dehumidification_hysteresis = jsn.at("DehumidificationHysteresis").get(); + + new_updated_state.dehumidification_hysteresis = true; + } + + if (jsn.find("DehumidificationMaxCool") != jsn.end()) { + +- new_state.dehumidification_max_cool = jsn.at("DehumidificationMaxCool").get(); ++ new_state.dehumidification_max_cool = jsn.at("DehumidificationMaxCool").get(); + + new_updated_state.dehumidification_max_cool = true; + } +@@ -10039,11 +10039,11 @@ std::string get_json_payload_for_color_control_move_to_hue_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_hue( + nlohmann::json &jsn, +- uint8_t &hue, ++ int8_t &hue, + + CCDirection &direction, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10062,7 +10062,7 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue( + return; + } + +- hue = jsn.at("Hue").get< uint8_t >(); ++ hue = jsn.at("Hue").get< int8_t >(); + if (jsn.at("Direction").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10073,7 +10073,7 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue( + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10141,7 +10141,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -10165,7 +10165,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + return; + } + +- rate = jsn.at("Rate").get< uint8_t >(); ++ rate = jsn.at("Rate").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10237,9 +10237,9 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint8_t &transition_time, ++ int8_t &transition_time, + + uint8_t &options_mask, + +@@ -10263,13 +10263,13 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + return; + } + +- step_size = jsn.at("StepSize").get< uint8_t >(); ++ step_size = jsn.at("StepSize").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint8_t >(); ++ transition_time = jsn.at("TransitionTime").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10324,9 +10324,9 @@ std::string get_json_payload_for_color_control_move_to_saturation_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + nlohmann::json &jsn, +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10339,13 +10339,13 @@ void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + return; + } + +- saturation = jsn.at("Saturation").get< uint8_t >(); ++ saturation = jsn.at("Saturation").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10413,7 +10413,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -10437,7 +10437,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + return; + } + +- rate = jsn.at("Rate").get< uint8_t >(); ++ rate = jsn.at("Rate").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10509,9 +10509,9 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint8_t &transition_time, ++ int8_t &transition_time, + + uint8_t &options_mask, + +@@ -10535,13 +10535,13 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + return; + } + +- step_size = jsn.at("StepSize").get< uint8_t >(); ++ step_size = jsn.at("StepSize").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint8_t >(); ++ transition_time = jsn.at("TransitionTime").get< int8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10600,11 +10600,11 @@ std::string get_json_payload_for_color_control_move_to_hue_and_saturation_comman + + void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + nlohmann::json &jsn, +- uint8_t &hue, ++ int8_t &hue, + +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10617,19 +10617,19 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + return; + } + +- hue = jsn.at("Hue").get< uint8_t >(); ++ hue = jsn.at("Hue").get< int8_t >(); + if (jsn.at("Saturation").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- saturation = jsn.at("Saturation").get< uint8_t >(); ++ saturation = jsn.at("Saturation").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10688,11 +10688,11 @@ std::string get_json_payload_for_color_control_move_to_color_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_color( + nlohmann::json &jsn, +- uint16_t &colorx, ++ int16_t &colorx, + +- uint16_t &colory, ++ int16_t &colory, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10705,19 +10705,19 @@ void uic_mqtt_dotdot_parse_color_control_move_to_color( + return; + } + +- colorx = jsn.at("ColorX").get< uint16_t >(); ++ colorx = jsn.at("ColorX").get< int16_t >(); + if (jsn.at("ColorY").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- colory = jsn.at("ColorY").get< uint16_t >(); ++ colory = jsn.at("ColorY").get< int16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10856,7 +10856,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + + int16_t &stepy, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10881,7 +10881,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10936,9 +10936,9 @@ std::string get_json_payload_for_color_control_move_to_color_temperature_command + + void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + nlohmann::json &jsn, +- uint16_t &color_temperature_mireds, ++ int16_t &color_temperature_mireds, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -10951,13 +10951,13 @@ void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + return; + } + +- color_temperature_mireds = jsn.at("ColorTemperatureMireds").get< uint16_t >(); ++ color_temperature_mireds = jsn.at("ColorTemperatureMireds").get< int16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11027,11 +11027,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_command( + + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + nlohmann::json &jsn, +- uint16_t &enhanced_hue, ++ int16_t &enhanced_hue, + + CCDirection &direction, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -11050,7 +11050,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + return; + } + +- enhanced_hue = jsn.at("EnhancedHue").get< uint16_t >(); ++ enhanced_hue = jsn.at("EnhancedHue").get< int16_t >(); + if (jsn.at("Direction").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11061,7 +11061,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11129,7 +11129,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint16_t &rate, ++ int16_t &rate, + + uint8_t &options_mask, + +@@ -11153,7 +11153,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + return; + } + +- rate = jsn.at("Rate").get< uint16_t >(); ++ rate = jsn.at("Rate").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11225,9 +11225,9 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint16_t &step_size, ++ int16_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -11251,13 +11251,13 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + return; + } + +- step_size = jsn.at("StepSize").get< uint16_t >(); ++ step_size = jsn.at("StepSize").get< int16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11316,11 +11316,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_and_saturati + + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + nlohmann::json &jsn, +- uint16_t &enhanced_hue, ++ int16_t &enhanced_hue, + +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -11333,19 +11333,19 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + return; + } + +- enhanced_hue = jsn.at("EnhancedHue").get< uint16_t >(); ++ enhanced_hue = jsn.at("EnhancedHue").get< int16_t >(); + if (jsn.at("Saturation").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- saturation = jsn.at("Saturation").get< uint8_t >(); ++ saturation = jsn.at("Saturation").get< int8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11442,9 +11442,9 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + + CCColorLoopDirection &direction, + +- uint16_t &time, ++ int16_t &time, + +- uint16_t &start_hue, ++ int16_t &start_hue, + + uint8_t &options_mask, + +@@ -11484,13 +11484,13 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + return; + } + +- time = jsn.at("Time").get< uint16_t >(); ++ time = jsn.at("Time").get< int16_t >(); + if (jsn.at("StartHue").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_hue = jsn.at("StartHue").get< uint16_t >(); ++ start_hue = jsn.at("StartHue").get< int16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11618,11 +11618,11 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint16_t &rate, ++ int16_t &rate, + +- uint16_t &color_temperature_minimum_mireds, ++ uint8_t * &color_temperature_minimum_mireds, + +- uint16_t &color_temperature_maximum_mireds, ++ uint8_t * &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -11646,19 +11646,19 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + return; + } + +- rate = jsn.at("Rate").get< uint16_t >(); ++ rate = jsn.at("Rate").get< int16_t >(); + if (jsn.at("ColorTemperatureMinimumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint16_t >(); ++ color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint8_t * >(); + if (jsn.at("ColorTemperatureMaximumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint16_t >(); ++ color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint8_t * >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11738,13 +11738,13 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint16_t &step_size, ++ int16_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + +- uint16_t &color_temperature_minimum_mireds, ++ uint8_t * &color_temperature_minimum_mireds, + +- uint16_t &color_temperature_maximum_mireds, ++ uint8_t * &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -11768,25 +11768,25 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + return; + } + +- step_size = jsn.at("StepSize").get< uint16_t >(); ++ step_size = jsn.at("StepSize").get< int16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< uint16_t >(); ++ transition_time = jsn.at("TransitionTime").get< int16_t >(); + if (jsn.at("ColorTemperatureMinimumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint16_t >(); ++ color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint8_t * >(); + if (jsn.at("ColorTemperatureMaximumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint16_t >(); ++ color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint8_t * >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11821,84 +11821,84 @@ void uic_mqtt_dotdot_parse_color_control_write_attributes( + + if (jsn.find("WhitePointX") != jsn.end()) { + +- new_state.white_pointx = jsn.at("WhitePointX").get(); ++ new_state.white_pointx = jsn.at("WhitePointX").get(); + + new_updated_state.white_pointx = true; + } + + if (jsn.find("WhitePointY") != jsn.end()) { + +- new_state.white_pointy = jsn.at("WhitePointY").get(); ++ new_state.white_pointy = jsn.at("WhitePointY").get(); + + new_updated_state.white_pointy = true; + } + + if (jsn.find("ColorPointRX") != jsn.end()) { + +- new_state.color_pointrx = jsn.at("ColorPointRX").get(); ++ new_state.color_pointrx = jsn.at("ColorPointRX").get(); + + new_updated_state.color_pointrx = true; + } + + if (jsn.find("ColorPointRY") != jsn.end()) { + +- new_state.color_pointry = jsn.at("ColorPointRY").get(); ++ new_state.color_pointry = jsn.at("ColorPointRY").get(); + + new_updated_state.color_pointry = true; + } + + if (jsn.find("ColorPointRIntensity") != jsn.end()) { + +- new_state.color_pointr_intensity = jsn.at("ColorPointRIntensity").get(); ++ new_state.color_pointr_intensity = jsn.at("ColorPointRIntensity").get(); + + new_updated_state.color_pointr_intensity = true; + } + + if (jsn.find("ColorPointGX") != jsn.end()) { + +- new_state.color_pointgx = jsn.at("ColorPointGX").get(); ++ new_state.color_pointgx = jsn.at("ColorPointGX").get(); + + new_updated_state.color_pointgx = true; + } + + if (jsn.find("ColorPointGY") != jsn.end()) { + +- new_state.color_pointgy = jsn.at("ColorPointGY").get(); ++ new_state.color_pointgy = jsn.at("ColorPointGY").get(); + + new_updated_state.color_pointgy = true; + } + + if (jsn.find("ColorPointGIntensity") != jsn.end()) { + +- new_state.color_pointg_intensity = jsn.at("ColorPointGIntensity").get(); ++ new_state.color_pointg_intensity = jsn.at("ColorPointGIntensity").get(); + + new_updated_state.color_pointg_intensity = true; + } + + if (jsn.find("ColorPointBX") != jsn.end()) { + +- new_state.color_pointbx = jsn.at("ColorPointBX").get(); ++ new_state.color_pointbx = jsn.at("ColorPointBX").get(); + + new_updated_state.color_pointbx = true; + } + + if (jsn.find("ColorPointBY") != jsn.end()) { + +- new_state.color_pointby = jsn.at("ColorPointBY").get(); ++ new_state.color_pointby = jsn.at("ColorPointBY").get(); + + new_updated_state.color_pointby = true; + } + + if (jsn.find("ColorPointBIntensity") != jsn.end()) { + +- new_state.color_pointb_intensity = jsn.at("ColorPointBIntensity").get(); ++ new_state.color_pointb_intensity = jsn.at("ColorPointBIntensity").get(); + + new_updated_state.color_pointb_intensity = true; + } + + if (jsn.find("StartUpColorTemperatureMireds") != jsn.end()) { + +- new_state.start_up_color_temperature_mireds = jsn.at("StartUpColorTemperatureMireds").get(); ++ new_state.start_up_color_temperature_mireds = jsn.at("StartUpColorTemperatureMireds").get(); + + new_updated_state.start_up_color_temperature_mireds = true; + } +@@ -11921,42 +11921,42 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("MinLevel") != jsn.end()) { + +- new_state.min_level = jsn.at("MinLevel").get(); ++ new_state.min_level = jsn.at("MinLevel").get(); + + new_updated_state.min_level = true; + } + + if (jsn.find("MaxLevel") != jsn.end()) { + +- new_state.max_level = jsn.at("MaxLevel").get(); ++ new_state.max_level = jsn.at("MaxLevel").get(); + + new_updated_state.max_level = true; + } + + if (jsn.find("PowerOnLevel") != jsn.end()) { + +- new_state.power_on_level = jsn.at("PowerOnLevel").get(); ++ new_state.power_on_level = jsn.at("PowerOnLevel").get(); + + new_updated_state.power_on_level = true; + } + + if (jsn.find("PowerOnFadeTime") != jsn.end()) { + +- new_state.power_on_fade_time = jsn.at("PowerOnFadeTime").get(); ++ new_state.power_on_fade_time = jsn.at("PowerOnFadeTime").get(); + + new_updated_state.power_on_fade_time = true; + } + + if (jsn.find("IntrinsicBallastFactor") != jsn.end()) { + +- new_state.intrinsic_ballast_factor = jsn.at("IntrinsicBallastFactor").get(); ++ new_state.intrinsic_ballast_factor = jsn.at("IntrinsicBallastFactor").get(); + + new_updated_state.intrinsic_ballast_factor = true; + } + + if (jsn.find("BallastFactorAdjustment") != jsn.end()) { + +- new_state.ballast_factor_adjustment = jsn.at("BallastFactorAdjustment").get(); ++ new_state.ballast_factor_adjustment = jsn.at("BallastFactorAdjustment").get(); + + new_updated_state.ballast_factor_adjustment = true; + } +@@ -11977,14 +11977,14 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("LampRatedHours") != jsn.end()) { + +- new_state.lamp_rated_hours = jsn.at("LampRatedHours").get(); ++ new_state.lamp_rated_hours = jsn.at("LampRatedHours").get(); + + new_updated_state.lamp_rated_hours = true; + } + + if (jsn.find("LampBurnHours") != jsn.end()) { + +- new_state.lamp_burn_hours = jsn.at("LampBurnHours").get(); ++ new_state.lamp_burn_hours = jsn.at("LampBurnHours").get(); + + new_updated_state.lamp_burn_hours = true; + } +@@ -11998,7 +11998,7 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("LampBurnHoursTripPoint") != jsn.end()) { + +- new_state.lamp_burn_hours_trip_point = jsn.at("LampBurnHoursTripPoint").get(); ++ new_state.lamp_burn_hours_trip_point = jsn.at("LampBurnHoursTripPoint").get(); + + new_updated_state.lamp_burn_hours_trip_point = true; + } +@@ -12037,7 +12037,7 @@ void uic_mqtt_dotdot_parse_illuminance_level_sensing_write_attributes( + + if (jsn.find("IlluminanceTargetLevel") != jsn.end()) { + +- new_state.illuminance_target_level = jsn.at("IlluminanceTargetLevel").get(); ++ new_state.illuminance_target_level = jsn.at("IlluminanceTargetLevel").get(); + + new_updated_state.illuminance_target_level = true; + } +@@ -12124,63 +12124,63 @@ void uic_mqtt_dotdot_parse_occupancy_sensing_write_attributes( + + if (jsn.find("PIROccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.pir_occupied_to_unoccupied_delay = jsn.at("PIROccupiedToUnoccupiedDelay").get(); ++ new_state.pir_occupied_to_unoccupied_delay = jsn.at("PIROccupiedToUnoccupiedDelay").get(); + + new_updated_state.pir_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("PIRUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.pir_unoccupied_to_occupied_delay = jsn.at("PIRUnoccupiedToOccupiedDelay").get(); ++ new_state.pir_unoccupied_to_occupied_delay = jsn.at("PIRUnoccupiedToOccupiedDelay").get(); + + new_updated_state.pir_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("PIRUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.pir_unoccupied_to_occupied_threshold = jsn.at("PIRUnoccupiedToOccupiedThreshold").get(); ++ new_state.pir_unoccupied_to_occupied_threshold = jsn.at("PIRUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.pir_unoccupied_to_occupied_threshold = true; + } + + if (jsn.find("UltrasonicOccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.ultrasonic_occupied_to_unoccupied_delay = jsn.at("UltrasonicOccupiedToUnoccupiedDelay").get(); ++ new_state.ultrasonic_occupied_to_unoccupied_delay = jsn.at("UltrasonicOccupiedToUnoccupiedDelay").get(); + + new_updated_state.ultrasonic_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("UltrasonicUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.ultrasonic_unoccupied_to_occupied_delay = jsn.at("UltrasonicUnoccupiedToOccupiedDelay").get(); ++ new_state.ultrasonic_unoccupied_to_occupied_delay = jsn.at("UltrasonicUnoccupiedToOccupiedDelay").get(); + + new_updated_state.ultrasonic_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("UltrasonicUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.ultrasonic_unoccupied_to_occupied_threshold = jsn.at("UltrasonicUnoccupiedToOccupiedThreshold").get(); ++ new_state.ultrasonic_unoccupied_to_occupied_threshold = jsn.at("UltrasonicUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.ultrasonic_unoccupied_to_occupied_threshold = true; + } + + if (jsn.find("PhysicalContactOccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.physical_contact_occupied_to_unoccupied_delay = jsn.at("PhysicalContactOccupiedToUnoccupiedDelay").get(); ++ new_state.physical_contact_occupied_to_unoccupied_delay = jsn.at("PhysicalContactOccupiedToUnoccupiedDelay").get(); + + new_updated_state.physical_contact_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("PhysicalContactUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.physical_contact_unoccupied_to_occupied_delay = jsn.at("PhysicalContactUnoccupiedToOccupiedDelay").get(); ++ new_state.physical_contact_unoccupied_to_occupied_delay = jsn.at("PhysicalContactUnoccupiedToOccupiedDelay").get(); + + new_updated_state.physical_contact_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("PhysicalContactUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.physical_contact_unoccupied_to_occupied_threshold = jsn.at("PhysicalContactUnoccupiedToOccupiedThreshold").get(); ++ new_state.physical_contact_unoccupied_to_occupied_threshold = jsn.at("PhysicalContactUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.physical_contact_unoccupied_to_occupied_threshold = true; + } +@@ -12343,7 +12343,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + nlohmann::json &jsn, + ZoneEnrollResponseEnrollResponseCode &enroll_response_code, + +- uint8_t &zoneid ++ int8_t &zoneid + + ) { + +@@ -12363,7 +12363,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + return; + } + +- zoneid = jsn.at("ZoneID").get< uint8_t >(); ++ zoneid = jsn.at("ZoneID").get< int8_t >(); + } + + +@@ -12410,9 +12410,9 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + + uint8_t &extended_status, + +- uint8_t &zoneid, ++ int8_t &zoneid, + +- uint16_t &delay ++ int16_t &delay + + ) { + +@@ -12431,13 +12431,13 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + return; + } + +- zoneid = jsn.at("ZoneID").get< uint8_t >(); ++ zoneid = jsn.at("ZoneID").get< int8_t >(); + if (jsn.at("Delay").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- delay = jsn.at("Delay").get< uint16_t >(); ++ delay = jsn.at("Delay").get< int16_t >(); + } + + +@@ -12502,7 +12502,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + nlohmann::json &jsn, + IasZoneType &zone_type, + +- uint16_t &manufacturer_code ++ int16_t &manufacturer_code + + ) { + +@@ -12522,7 +12522,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + return; + } + +- manufacturer_code = jsn.at("ManufacturerCode").get< uint16_t >(); ++ manufacturer_code = jsn.at("ManufacturerCode").get< int16_t >(); + } + + +@@ -12555,9 +12555,9 @@ std::string get_json_payload_for_ias_zone_initiate_test_mode_command( + + void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + nlohmann::json &jsn, +- uint8_t &test_mode_duration, ++ int8_t &test_mode_duration, + +- uint8_t ¤t_zone_sensitivity_level ++ int8_t ¤t_zone_sensitivity_level + + ) { + +@@ -12566,13 +12566,13 @@ void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + return; + } + +- test_mode_duration = jsn.at("TestModeDuration").get< uint8_t >(); ++ test_mode_duration = jsn.at("TestModeDuration").get< int8_t >(); + if (jsn.at("CurrentZoneSensitivityLevel").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get< uint8_t >(); ++ current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get< int8_t >(); + } + + +@@ -12597,7 +12597,7 @@ void uic_mqtt_dotdot_parse_ias_zone_write_attributes( + + if (jsn.find("CurrentZoneSensitivityLevel") != jsn.end()) { + +- new_state.current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get(); ++ new_state.current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get(); + + new_updated_state.current_zone_sensitivity_level = true; + } +@@ -12658,9 +12658,9 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + nlohmann::json &jsn, + uint8_t &siren_configuration, + +- uint16_t &warning_duration, ++ int16_t &warning_duration, + +- uint8_t &strobe_duty_cycle, ++ int8_t &strobe_duty_cycle, + + IaswdLevel &strobe_level + +@@ -12682,13 +12682,13 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + return; + } + +- warning_duration = jsn.at("WarningDuration").get< uint16_t >(); ++ warning_duration = jsn.at("WarningDuration").get< int16_t >(); + if (jsn.at("StrobeDutyCycle").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- strobe_duty_cycle = jsn.at("StrobeDutyCycle").get< uint8_t >(); ++ strobe_duty_cycle = jsn.at("StrobeDutyCycle").get< int8_t >(); + if (jsn.at("StrobeLevel").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -12750,7 +12750,7 @@ void uic_mqtt_dotdot_parse_iaswd_write_attributes( + + if (jsn.find("MaxDuration") != jsn.end()) { + +- new_state.max_duration = jsn.at("MaxDuration").get(); ++ new_state.max_duration = jsn.at("MaxDuration").get(); + + new_updated_state.max_duration = true; + } +@@ -12809,7 +12809,7 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + json_payload["MaxNumberOfIntervals"] = nlohmann::json(fields->max_number_of_intervals); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["ListOfAttributes"] = std::vector< uint16_t >( ++ json_payload["ListOfAttributes"] = std::vector< uint8_t >( + fields->list_of_attributes, + fields->list_of_attributes + fields->list_of_attributes_count); + +@@ -12825,13 +12825,13 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + + void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + nlohmann::json &jsn, +- uint8_t &profile_count, ++ int8_t &profile_count, + + ProfileIntervalPeriod &profile_interval_period, + +- uint8_t &max_number_of_intervals, ++ int8_t &max_number_of_intervals, + +- std::vector &list_of_attributes ++ std::vector &list_of_attributes + + ) { + +@@ -12846,7 +12846,7 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + return; + } + +- profile_count = jsn.at("ProfileCount").get< uint8_t >(); ++ profile_count = jsn.at("ProfileCount").get< int8_t >(); + if (jsn.at("ProfileIntervalPeriod").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -12857,13 +12857,13 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + return; + } + +- max_number_of_intervals = jsn.at("MaxNumberOfIntervals").get< uint8_t >(); ++ max_number_of_intervals = jsn.at("MaxNumberOfIntervals").get< int8_t >(); + if (jsn.at("ListOfAttributes").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- list_of_attributes = jsn.at("ListOfAttributes").get< std::vector< uint16_t >>(); ++ list_of_attributes = jsn.at("ListOfAttributes").get< std::vector< uint8_t >>(); + } + + +@@ -12939,7 +12939,7 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + json_payload["AttributeId"] = nlohmann::json(fields->attribute_id); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["Intervals"] = std::vector< uint8_t >( ++ json_payload["Intervals"] = std::vector< int8_t >( + fields->intervals, + fields->intervals + fields->intervals_count); + +@@ -12955,17 +12955,17 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_response( + nlohmann::json &jsn, +- uint32_t &start_time, ++ uint8_t &start_time, + + GetMeasurementProfileResponseStatus &status, + + ProfileIntervalPeriod &profile_interval_period, + +- uint8_t &number_of_intervals_delivered, ++ int8_t &number_of_intervals_delivered, + +- uint16_t &attribute_id, ++ uint8_t &attribute_id, + +- std::vector &intervals ++ std::vector &intervals + + ) { + +@@ -12986,7 +12986,7 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_respon + return; + } + +- start_time = jsn.at("StartTime").get< uint32_t >(); ++ start_time = jsn.at("StartTime").get< uint8_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13002,19 +13002,19 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_respon + return; + } + +- number_of_intervals_delivered = jsn.at("NumberOfIntervalsDelivered").get< uint8_t >(); ++ number_of_intervals_delivered = jsn.at("NumberOfIntervalsDelivered").get< int8_t >(); + if (jsn.at("AttributeId").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- attribute_id = jsn.at("AttributeId").get< uint16_t >(); ++ attribute_id = jsn.at("AttributeId").get< uint8_t >(); + if (jsn.at("Intervals").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- intervals = jsn.at("Intervals").get< std::vector< uint8_t >>(); ++ intervals = jsn.at("Intervals").get< std::vector< int8_t >>(); + } + + +@@ -13051,11 +13051,11 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + nlohmann::json &jsn, +- uint16_t &attributeid, ++ uint8_t &attributeid, + +- uint32_t &start_time, ++ uint8_t &start_time, + +- uint8_t &number_of_intervals ++ int8_t &number_of_intervals + + ) { + +@@ -13064,19 +13064,19 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + return; + } + +- attributeid = jsn.at("AttributeID").get< uint16_t >(); ++ attributeid = jsn.at("AttributeID").get< uint8_t >(); + if (jsn.at("StartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_time = jsn.at("StartTime").get< uint32_t >(); ++ start_time = jsn.at("StartTime").get< uint8_t >(); + if (jsn.at("NumberOfIntervals").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- number_of_intervals = jsn.at("NumberOfIntervals").get< uint8_t >(); ++ number_of_intervals = jsn.at("NumberOfIntervals").get< int8_t >(); + } + + +@@ -13094,49 +13094,49 @@ void uic_mqtt_dotdot_parse_electrical_measurement_write_attributes( + + if (jsn.find("AverageRMSVoltageMeasurementPeriod") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period = jsn.at("AverageRMSVoltageMeasurementPeriod").get(); ++ new_state.average_rms_voltage_measurement_period = jsn.at("AverageRMSVoltageMeasurementPeriod").get(); + + new_updated_state.average_rms_voltage_measurement_period = true; + } + + if (jsn.find("AverageRMSOverVoltageCounter") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter = jsn.at("AverageRMSOverVoltageCounter").get(); ++ new_state.average_rms_over_voltage_counter = jsn.at("AverageRMSOverVoltageCounter").get(); + + new_updated_state.average_rms_over_voltage_counter = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounter") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter = jsn.at("AverageRMSUnderVoltageCounter").get(); ++ new_state.average_rms_under_voltage_counter = jsn.at("AverageRMSUnderVoltageCounter").get(); + + new_updated_state.average_rms_under_voltage_counter = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriod") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period = jsn.at("RMSExtremeOverVoltagePeriod").get(); ++ new_state.rms_extreme_over_voltage_period = jsn.at("RMSExtremeOverVoltagePeriod").get(); + + new_updated_state.rms_extreme_over_voltage_period = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriod") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period = jsn.at("RMSExtremeUnderVoltagePeriod").get(); ++ new_state.rms_extreme_under_voltage_period = jsn.at("RMSExtremeUnderVoltagePeriod").get(); + + new_updated_state.rms_extreme_under_voltage_period = true; + } + + if (jsn.find("RMSVoltageSagPeriod") != jsn.end()) { + +- new_state.rms_voltage_sag_period = jsn.at("RMSVoltageSagPeriod").get(); ++ new_state.rms_voltage_sag_period = jsn.at("RMSVoltageSagPeriod").get(); + + new_updated_state.rms_voltage_sag_period = true; + } + + if (jsn.find("RMSVoltageSwellPeriod") != jsn.end()) { + +- new_state.rms_voltage_swell_period = jsn.at("RMSVoltageSwellPeriod").get(); ++ new_state.rms_voltage_swell_period = jsn.at("RMSVoltageSwellPeriod").get(); + + new_updated_state.rms_voltage_swell_period = true; + } +@@ -13185,98 +13185,98 @@ void uic_mqtt_dotdot_parse_electrical_measurement_write_attributes( + + if (jsn.find("AverageRMSVoltageMeasurementPeriodPhB") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period_phb = jsn.at("AverageRMSVoltageMeasurementPeriodPhB").get(); ++ new_state.average_rms_voltage_measurement_period_phb = jsn.at("AverageRMSVoltageMeasurementPeriodPhB").get(); + + new_updated_state.average_rms_voltage_measurement_period_phb = true; + } + + if (jsn.find("AverageRMSOverVoltageCounterPhB") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter_phb = jsn.at("AverageRMSOverVoltageCounterPhB").get(); ++ new_state.average_rms_over_voltage_counter_phb = jsn.at("AverageRMSOverVoltageCounterPhB").get(); + + new_updated_state.average_rms_over_voltage_counter_phb = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounterPhB") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter_phb = jsn.at("AverageRMSUnderVoltageCounterPhB").get(); ++ new_state.average_rms_under_voltage_counter_phb = jsn.at("AverageRMSUnderVoltageCounterPhB").get(); + + new_updated_state.average_rms_under_voltage_counter_phb = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriodPhB") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period_phb = jsn.at("RMSExtremeOverVoltagePeriodPhB").get(); ++ new_state.rms_extreme_over_voltage_period_phb = jsn.at("RMSExtremeOverVoltagePeriodPhB").get(); + + new_updated_state.rms_extreme_over_voltage_period_phb = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriodPhB") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period_phb = jsn.at("RMSExtremeUnderVoltagePeriodPhB").get(); ++ new_state.rms_extreme_under_voltage_period_phb = jsn.at("RMSExtremeUnderVoltagePeriodPhB").get(); + + new_updated_state.rms_extreme_under_voltage_period_phb = true; + } + + if (jsn.find("RMSVoltageSagPeriodPhB") != jsn.end()) { + +- new_state.rms_voltage_sag_period_phb = jsn.at("RMSVoltageSagPeriodPhB").get(); ++ new_state.rms_voltage_sag_period_phb = jsn.at("RMSVoltageSagPeriodPhB").get(); + + new_updated_state.rms_voltage_sag_period_phb = true; + } + + if (jsn.find("RMSVoltageSwellPeriodPhB") != jsn.end()) { + +- new_state.rms_voltage_swell_period_phb = jsn.at("RMSVoltageSwellPeriodPhB").get(); ++ new_state.rms_voltage_swell_period_phb = jsn.at("RMSVoltageSwellPeriodPhB").get(); + + new_updated_state.rms_voltage_swell_period_phb = true; + } + + if (jsn.find("AverageRMSVoltageMeasurementPeriodPhC") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period_phc = jsn.at("AverageRMSVoltageMeasurementPeriodPhC").get(); ++ new_state.average_rms_voltage_measurement_period_phc = jsn.at("AverageRMSVoltageMeasurementPeriodPhC").get(); + + new_updated_state.average_rms_voltage_measurement_period_phc = true; + } + + if (jsn.find("AverageRMSOverVoltageCounterPhC") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter_phc = jsn.at("AverageRMSOverVoltageCounterPhC").get(); ++ new_state.average_rms_over_voltage_counter_phc = jsn.at("AverageRMSOverVoltageCounterPhC").get(); + + new_updated_state.average_rms_over_voltage_counter_phc = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounterPhC") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter_phc = jsn.at("AverageRMSUnderVoltageCounterPhC").get(); ++ new_state.average_rms_under_voltage_counter_phc = jsn.at("AverageRMSUnderVoltageCounterPhC").get(); + + new_updated_state.average_rms_under_voltage_counter_phc = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriodPhC") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period_phc = jsn.at("RMSExtremeOverVoltagePeriodPhC").get(); ++ new_state.rms_extreme_over_voltage_period_phc = jsn.at("RMSExtremeOverVoltagePeriodPhC").get(); + + new_updated_state.rms_extreme_over_voltage_period_phc = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriodPhC") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period_phc = jsn.at("RMSExtremeUnderVoltagePeriodPhC").get(); ++ new_state.rms_extreme_under_voltage_period_phc = jsn.at("RMSExtremeUnderVoltagePeriodPhC").get(); + + new_updated_state.rms_extreme_under_voltage_period_phc = true; + } + + if (jsn.find("RMSVoltageSagPeriodPhC") != jsn.end()) { + +- new_state.rms_voltage_sag_period_phc = jsn.at("RMSVoltageSagPeriodPhC").get(); ++ new_state.rms_voltage_sag_period_phc = jsn.at("RMSVoltageSagPeriodPhC").get(); + + new_updated_state.rms_voltage_sag_period_phc = true; + } + + if (jsn.find("RMSVoltageSwellPeriodPhC") != jsn.end()) { + +- new_state.rms_voltage_swell_period_phc = jsn.at("RMSVoltageSwellPeriodPhC").get(); ++ new_state.rms_voltage_swell_period_phc = jsn.at("RMSVoltageSwellPeriodPhC").get(); + + new_updated_state.rms_voltage_swell_period_phc = true; + } +@@ -13419,13 +13419,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + bool &transmission_successful, + +- uint16_t &transmission_time_ms, ++ int16_t &transmission_time_ms, + + int8_t &tx_powerd_bm, + +- uint8_t &tx_channel, ++ int8_t &tx_channel, + +- uint8_t &routing_attempts, ++ int8_t &routing_attempts, + + bool &route_changed, + +@@ -13439,7 +13439,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + int8_t &ackrssi, + +- uint8_t &ack_channel, ++ int8_t &ack_channel, + + std::string &last_route_failed_link_functionalunid, + +@@ -13482,7 +13482,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- transmission_time_ms = jsn.at("TransmissionTimeMs").get< uint16_t >(); ++ transmission_time_ms = jsn.at("TransmissionTimeMs").get< int16_t >(); + if (jsn.at("TxPowerdBm").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13494,13 +13494,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- tx_channel = jsn.at("TxChannel").get< uint8_t >(); ++ tx_channel = jsn.at("TxChannel").get< int8_t >(); + if (jsn.at("RoutingAttempts").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- routing_attempts = jsn.at("RoutingAttempts").get< uint8_t >(); ++ routing_attempts = jsn.at("RoutingAttempts").get< int8_t >(); + if (jsn.at("RouteChanged").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13543,7 +13543,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- ack_channel = jsn.at("AckChannel").get< uint8_t >(); ++ ack_channel = jsn.at("AckChannel").get< int8_t >(); + if (jsn.at("LastRouteFailedLinkFunctionalUNID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13774,7 +13774,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + + std::string &destination_unid, + +- uint8_t &destination_ep ++ int8_t &destination_ep + + ) { + +@@ -13795,7 +13795,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + return; + } + +- destination_ep = jsn.at("DestinationEp").get< uint8_t >(); ++ destination_ep = jsn.at("DestinationEp").get< int8_t >(); + } + + +@@ -13836,7 +13836,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + + std::string &destination_unid, + +- uint8_t &destination_ep ++ int8_t &destination_ep + + ) { + +@@ -13857,7 +13857,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + return; + } + +- destination_ep = jsn.at("DestinationEp").get< uint8_t >(); ++ destination_ep = jsn.at("DestinationEp").get< int8_t >(); + } + + +@@ -13967,7 +13967,7 @@ void uic_mqtt_dotdot_parse_system_metrics_write_attributes( + + if (jsn.find("ReportingIntervalSeconds") != jsn.end()) { + +- new_state.reporting_interval_seconds = jsn.at("ReportingIntervalSeconds").get(); ++ new_state.reporting_interval_seconds = jsn.at("ReportingIntervalSeconds").get(); + + new_updated_state.reporting_interval_seconds = true; + } +@@ -14102,14 +14102,14 @@ void uic_mqtt_dotdot_parse_application_monitoring_write_attributes( + + if (jsn.find("MQTTStatisticsReportingIntervalSeconds") != jsn.end()) { + +- new_state.mqtt_statistics_reporting_interval_seconds = jsn.at("MQTTStatisticsReportingIntervalSeconds").get(); ++ new_state.mqtt_statistics_reporting_interval_seconds = jsn.at("MQTTStatisticsReportingIntervalSeconds").get(); + + new_updated_state.mqtt_statistics_reporting_interval_seconds = true; + } + + if (jsn.find("ApplicationStatisticsReportingIntervalSeconds") != jsn.end()) { + +- new_state.application_statistics_reporting_interval_seconds = jsn.at("ApplicationStatisticsReportingIntervalSeconds").get(); ++ new_state.application_statistics_reporting_interval_seconds = jsn.at("ApplicationStatisticsReportingIntervalSeconds").get(); + + new_updated_state.application_statistics_reporting_interval_seconds = true; + } +@@ -14173,7 +14173,7 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_com + + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + nlohmann::json &jsn, +- uint16_t ¶meter_id ++ int16_t ¶meter_id + + ) { + +@@ -14182,7 +14182,7 @@ void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + return; + } + +- parameter_id = jsn.at("ParameterId").get< uint16_t >(); ++ parameter_id = jsn.at("ParameterId").get< int16_t >(); + } + + +@@ -14234,7 +14234,7 @@ std::string get_json_payload_for_configuration_parameters_set_parameter_command( + + void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + nlohmann::json &jsn, +- uint16_t ¶meter_id, ++ int16_t ¶meter_id, + + int64_t &value + +@@ -14245,7 +14245,7 @@ void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + return; + } + +- parameter_id = jsn.at("ParameterId").get< uint16_t >(); ++ parameter_id = jsn.at("ParameterId").get< int16_t >(); + if (jsn.at("Value").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14284,9 +14284,9 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_ran + + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + nlohmann::json &jsn, +- uint16_t &first_parameter_id, ++ int16_t &first_parameter_id, + +- uint16_t &last_parameter_id ++ int16_t &last_parameter_id + + ) { + +@@ -14295,13 +14295,13 @@ void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + return; + } + +- first_parameter_id = jsn.at("FirstParameterId").get< uint16_t >(); ++ first_parameter_id = jsn.at("FirstParameterId").get< int16_t >(); + if (jsn.at("LastParameterId").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- last_parameter_id = jsn.at("LastParameterId").get< uint16_t >(); ++ last_parameter_id = jsn.at("LastParameterId").get< int16_t >(); + } + + +@@ -14318,6 +14318,1299 @@ void uic_mqtt_dotdot_parse_configuration_parameters_write_attributes( + + + ++} ++ ++ ++std::string get_json_payload_for_user_credential_add_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum AddUser / UserType ++ #ifdef ADD_USER_USER_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["UserType"] = ++ add_user_user_type_get_enum_value_name( ++ (uint32_t)fields->user_type); ++ #elif defined(USER_TYPE_ENUM_ENUM_NAME_AVAILABLE) ++ json_payload["UserType"] = ++ user_type_enum_get_enum_value_name((uint32_t)fields->user_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["UserType"] = fields->user_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserActiveState"] = nlohmann::json(fields->user_active_state); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum AddUser / CredentialRule ++ #ifdef ADD_USER_CREDENTIAL_RULE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialRule"] = ++ add_user_credential_rule_get_enum_value_name( ++ (uint32_t)fields->credential_rule); ++ #elif defined(CRED_RULE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialRule"] = ++ cred_rule_get_enum_value_name((uint32_t)fields->credential_rule); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialRule"] = fields->credential_rule; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserName"] = nlohmann::json(fields->user_name); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["ExpiringTimeoutMinutes"] = nlohmann::json(fields->expiring_timeout_minutes); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum AddUser / UserNameEncoding ++ #ifdef ADD_USER_USER_NAME_ENCODING_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["UserNameEncoding"] = ++ add_user_user_name_encoding_get_enum_value_name( ++ (uint32_t)fields->user_name_encoding); ++ #elif defined(USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["UserNameEncoding"] = ++ user_name_encoding_type_get_enum_value_name((uint32_t)fields->user_name_encoding); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["UserNameEncoding"] = fields->user_name_encoding; ++ #endif ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_add_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ UserTypeEnum &user_type, ++ ++ bool &user_active_state, ++ ++ CredRule &credential_rule, ++ ++ std::string &user_name, ++ ++ int16_t &expiring_timeout_minutes, ++ ++ UserNameEncodingType &user_name_encoding ++ ++) { ++ ++ uint32_t UserType_enum_val = get_enum_decimal_value("UserType", jsn); ++ if (UserType_enum_val == std::numeric_limits::max()) { ++ #ifdef USER_TYPE_ENUM_ENUM_NAME_AVAILABLE ++ UserType_enum_val = user_type_enum_get_enum_value_number(jsn.at("UserType").get()); ++ #endif ++ } ++ uint32_t CredentialRule_enum_val = get_enum_decimal_value("CredentialRule", jsn); ++ if (CredentialRule_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_RULE_ENUM_NAME_AVAILABLE ++ CredentialRule_enum_val = cred_rule_get_enum_value_number(jsn.at("CredentialRule").get()); ++ #endif ++ } ++ uint32_t UserNameEncoding_enum_val = get_enum_decimal_value("UserNameEncoding", jsn); ++ if (UserNameEncoding_enum_val == std::numeric_limits::max()) { ++ #ifdef USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE ++ UserNameEncoding_enum_val = user_name_encoding_type_get_enum_value_number(jsn.at("UserNameEncoding").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("UserType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ user_type = static_cast(UserType_enum_val); ++ if (jsn.at("UserActiveState").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_active_state = jsn.at("UserActiveState").get< bool >(); ++ if (jsn.at("CredentialRule").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_rule = static_cast(CredentialRule_enum_val); ++ if (jsn.at("UserName").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_name = jsn.at("UserName").get(); ++ if (jsn.at("ExpiringTimeoutMinutes").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< int16_t >(); ++ if (jsn.at("UserNameEncoding").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ user_name_encoding = static_cast(UserNameEncoding_enum_val); ++} ++ ++ ++std::string get_json_payload_for_user_credential_modify_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum ModifyUser / UserType ++ #ifdef MODIFY_USER_USER_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["UserType"] = ++ modify_user_user_type_get_enum_value_name( ++ (uint32_t)fields->user_type); ++ #elif defined(USER_TYPE_ENUM_ENUM_NAME_AVAILABLE) ++ json_payload["UserType"] = ++ user_type_enum_get_enum_value_name((uint32_t)fields->user_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["UserType"] = fields->user_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserActiveState"] = nlohmann::json(fields->user_active_state); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum ModifyUser / CredentialRule ++ #ifdef MODIFY_USER_CREDENTIAL_RULE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialRule"] = ++ modify_user_credential_rule_get_enum_value_name( ++ (uint32_t)fields->credential_rule); ++ #elif defined(CRED_RULE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialRule"] = ++ cred_rule_get_enum_value_name((uint32_t)fields->credential_rule); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialRule"] = fields->credential_rule; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserName"] = nlohmann::json(fields->user_name); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["ExpiringTimeoutMinutes"] = nlohmann::json(fields->expiring_timeout_minutes); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum ModifyUser / UserNameEncoding ++ #ifdef MODIFY_USER_USER_NAME_ENCODING_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["UserNameEncoding"] = ++ modify_user_user_name_encoding_get_enum_value_name( ++ (uint32_t)fields->user_name_encoding); ++ #elif defined(USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["UserNameEncoding"] = ++ user_name_encoding_type_get_enum_value_name((uint32_t)fields->user_name_encoding); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["UserNameEncoding"] = fields->user_name_encoding; ++ #endif ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_modify_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ UserTypeEnum &user_type, ++ ++ bool &user_active_state, ++ ++ CredRule &credential_rule, ++ ++ std::string &user_name, ++ ++ int16_t &expiring_timeout_minutes, ++ ++ UserNameEncodingType &user_name_encoding ++ ++) { ++ ++ uint32_t UserType_enum_val = get_enum_decimal_value("UserType", jsn); ++ if (UserType_enum_val == std::numeric_limits::max()) { ++ #ifdef USER_TYPE_ENUM_ENUM_NAME_AVAILABLE ++ UserType_enum_val = user_type_enum_get_enum_value_number(jsn.at("UserType").get()); ++ #endif ++ } ++ uint32_t CredentialRule_enum_val = get_enum_decimal_value("CredentialRule", jsn); ++ if (CredentialRule_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_RULE_ENUM_NAME_AVAILABLE ++ CredentialRule_enum_val = cred_rule_get_enum_value_number(jsn.at("CredentialRule").get()); ++ #endif ++ } ++ uint32_t UserNameEncoding_enum_val = get_enum_decimal_value("UserNameEncoding", jsn); ++ if (UserNameEncoding_enum_val == std::numeric_limits::max()) { ++ #ifdef USER_NAME_ENCODING_TYPE_ENUM_NAME_AVAILABLE ++ UserNameEncoding_enum_val = user_name_encoding_type_get_enum_value_number(jsn.at("UserNameEncoding").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("UserType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ user_type = static_cast(UserType_enum_val); ++ if (jsn.at("UserActiveState").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_active_state = jsn.at("UserActiveState").get< bool >(); ++ if (jsn.at("CredentialRule").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_rule = static_cast(CredentialRule_enum_val); ++ if (jsn.at("UserName").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_name = jsn.at("UserName").get(); ++ if (jsn.at("ExpiringTimeoutMinutes").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< int16_t >(); ++ if (jsn.at("UserNameEncoding").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ user_name_encoding = static_cast(UserNameEncoding_enum_val); ++} ++ ++ ++std::string get_json_payload_for_user_credential_delete_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_delete_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++) { ++ ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_add_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum AddCredential / CredentialType ++ #ifdef ADD_CREDENTIAL_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ add_credential_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialSlot"] = nlohmann::json(fields->credential_slot); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialData"] = nlohmann::json(fields->credential_data); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_add_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ std::string &credential_data ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("CredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ if (jsn.at("CredentialData").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_data = jsn.at("CredentialData").get(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_modify_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum ModifyCredential / CredentialType ++ #ifdef MODIFY_CREDENTIAL_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ modify_credential_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialSlot"] = nlohmann::json(fields->credential_slot); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialData"] = nlohmann::json(fields->credential_data); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_modify_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ std::string &credential_data ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("CredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ if (jsn.at("CredentialData").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_data = jsn.at("CredentialData").get(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_delete_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum DeleteCredential / CredentialType ++ #ifdef DELETE_CREDENTIAL_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ delete_credential_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialSlot"] = nlohmann::json(fields->credential_slot); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_delete_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("CredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_delete_all_users_command( ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++ ++ ++std::string get_json_payload_for_user_credential_delete_all_credentials_command( ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++ ++ ++std::string get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Enum DeleteAllCredentialsByType / CredentialType ++ #ifdef DELETE_ALL_CREDENTIALS_BY_TYPE_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ delete_all_credentials_by_type_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_by_type( ++ nlohmann::json &jsn, ++ CredType &credential_type ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++} ++ ++ ++std::string get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++) { ++ ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum DeleteAllCredentialsForUserByType / CredentialType ++ #ifdef DELETE_ALL_CREDENTIALS_FOR_USER_BY_TYPE_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ delete_all_credentials_for_user_by_type_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++} ++ ++ ++std::string get_json_payload_for_user_credential_credential_learn_start_add_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum CredentialLearnStartAdd / CredentialType ++ #ifdef CREDENTIAL_LEARN_START_ADD_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ credential_learn_start_add_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialSlot"] = nlohmann::json(fields->credential_slot); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialLearnTimeout"] = nlohmann::json(fields->credential_learn_timeout); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ int8_t &credential_learn_timeout ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("CredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ if (jsn.at("CredentialLearnTimeout").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< int8_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_credential_learn_start_modify_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Enum CredentialLearnStartModify / CredentialType ++ #ifdef CREDENTIAL_LEARN_START_MODIFY_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ credential_learn_start_modify_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialSlot"] = nlohmann::json(fields->credential_slot); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["CredentialLearnTimeout"] = nlohmann::json(fields->credential_learn_timeout); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ int8_t &credential_learn_timeout ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("CredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ if (jsn.at("CredentialLearnTimeout").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< int8_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_credential_learn_stop_command( ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++ ++ ++std::string get_json_payload_for_user_credential_credential_association_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Enum CredentialAssociation / CredentialType ++ #ifdef CREDENTIAL_ASSOCIATION_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ credential_association_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["SourceUserUniqueID"] = nlohmann::json(fields->source_user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["SourceCredentialSlot"] = nlohmann::json(fields->source_credential_slot); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["DestinationUserUniqueID"] = nlohmann::json(fields->destination_user_uniqueid); ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["DestinationCredentialSlot"] = nlohmann::json(fields->destination_credential_slot); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_credential_association( ++ nlohmann::json &jsn, ++ CredType &credential_type, ++ ++ int16_t &source_user_uniqueid, ++ ++ int16_t &source_credential_slot, ++ ++ int16_t &destination_user_uniqueid, ++ ++ int16_t &destination_credential_slot ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++ if (jsn.at("SourceUserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ source_user_uniqueid = jsn.at("SourceUserUniqueID").get< int16_t >(); ++ if (jsn.at("SourceCredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ source_credential_slot = jsn.at("SourceCredentialSlot").get< int16_t >(); ++ if (jsn.at("DestinationUserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ destination_user_uniqueid = jsn.at("DestinationUserUniqueID").get< int16_t >(); ++ if (jsn.at("DestinationCredentialSlot").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ destination_credential_slot = jsn.at("DestinationCredentialSlot").get< int16_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_get_user_checksum_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["UserUniqueID"] = nlohmann::json(fields->user_uniqueid); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_get_user_checksum( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++) { ++ ++ if (jsn.at("UserUniqueID").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_get_credential_checksum_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Enum GetCredentialChecksum / CredentialType ++ #ifdef GET_CREDENTIAL_CHECKSUM_CREDENTIAL_TYPE_ENUM_NAME_AVAILABLE ++ // Pick up the name from the value. ++ json_payload["CredentialType"] = ++ get_credential_checksum_credential_type_get_enum_value_name( ++ (uint32_t)fields->credential_type); ++ #elif defined(CRED_TYPE_ENUM_NAME_AVAILABLE) ++ json_payload["CredentialType"] = ++ cred_type_get_enum_value_name((uint32_t)fields->credential_type); ++ #else ++ // If there is no name value for the enum, just write it directly. ++ json_payload["CredentialType"] = fields->credential_type; ++ #endif ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_get_credential_checksum( ++ nlohmann::json &jsn, ++ CredType &credential_type ++ ++) { ++ ++ uint32_t CredentialType_enum_val = get_enum_decimal_value("CredentialType", jsn); ++ if (CredentialType_enum_val == std::numeric_limits::max()) { ++ #ifdef CRED_TYPE_ENUM_NAME_AVAILABLE ++ CredentialType_enum_val = cred_type_get_enum_value_number(jsn.at("CredentialType").get()); ++ #endif ++ } ++ if (jsn.at("CredentialType").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ credential_type = static_cast(CredentialType_enum_val); ++} ++ ++ ++std::string get_json_payload_for_user_credential_get_all_users_checksum_command( ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++ ++ ++std::string get_json_payload_for_user_credential_set_admin_pin_code_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ command_with_no_fields = false; ++ // Single Value ++ // Non-enum and non-bitmask (struct, string or scalar) ++ json_payload["PINCode"] = nlohmann::json(fields->pin_code); ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++void uic_mqtt_dotdot_parse_user_credential_set_admin_pin_code( ++ nlohmann::json &jsn, ++ std::string &pin_code ++ ++) { ++ ++ if (jsn.at("PINCode").is_null()) { ++ sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); ++ return; ++ } ++ ++ pin_code = jsn.at("PINCode").get(); ++ } ++ ++ ++std::string get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ++){ ++ bool command_with_no_fields = true; ++ ++ // Create a JSON payload from all the parameters ++ nlohmann::json json_payload; ++ ++ // Get the string ++ if (command_with_no_fields == true) { ++ return std::string("{}"); ++ } ++ // Payload may contain data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ return json_payload.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++} ++ ++ ++ ++ ++/** ++ * @brief JSON parser for ::WriteAttributes command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_write_attributes( ++ nlohmann::json &jsn, ++ uic_mqtt_dotdot_user_credential_state_t &new_state, ++ uic_mqtt_dotdot_user_credential_updated_state_t &new_updated_state ++) { ++ ++ ++ + } + + +@@ -14611,9 +15904,9 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + nlohmann::json &jsn, + SetpointType &type, + +- uint8_t &precision, ++ int8_t &precision, + +- uint8_t &scale, ++ int8_t &scale, + + int32_t &value + +@@ -14635,13 +15928,13 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + return; + } + +- precision = jsn.at("Precision").get< uint8_t >(); ++ precision = jsn.at("Precision").get< int8_t >(); + if (jsn.at("Scale").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scale = jsn.at("Scale").get< uint8_t >(); ++ scale = jsn.at("Scale").get< int8_t >(); + if (jsn.at("Value").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp +index 6f34c390dc..762addab76 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp +@@ -102,7 +102,7 @@ std::string get_json_payload_for_identify_identify_command( + */ + void uic_mqtt_dotdot_parse_identify_identify( + nlohmann::json &jsn, +- uint16_t &identify_time ++ int16_t &identify_time + + ); + +@@ -130,7 +130,7 @@ std::string get_json_payload_for_identify_identify_query_response_command( + */ + void uic_mqtt_dotdot_parse_identify_identify_query_response( + nlohmann::json &jsn, +- uint16_t &timeout ++ int16_t &timeout + + ); + +@@ -213,7 +213,7 @@ std::string get_json_payload_for_groups_add_group_command( + */ + void uic_mqtt_dotdot_parse_groups_add_group( + nlohmann::json &jsn, +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -245,7 +245,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id ++ int16_t &group_id + + ); + +@@ -273,7 +273,7 @@ std::string get_json_payload_for_groups_view_group_command( + */ + void uic_mqtt_dotdot_parse_groups_view_group( + nlohmann::json &jsn, +- uint16_t &group_id ++ int16_t &group_id + + ); + +@@ -303,7 +303,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -333,7 +333,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + */ + void uic_mqtt_dotdot_parse_groups_get_group_membership( + nlohmann::json &jsn, +- std::vector &group_list ++ std::vector &group_list + + ); + +@@ -361,9 +361,9 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + */ + void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + nlohmann::json &jsn, +- uint8_t &capacity, ++ int8_t &capacity, + +- std::vector &group_list ++ std::vector &group_list + + ); + +@@ -391,7 +391,7 @@ std::string get_json_payload_for_groups_remove_group_command( + */ + void uic_mqtt_dotdot_parse_groups_remove_group( + nlohmann::json &jsn, +- uint16_t &group_id ++ int16_t &group_id + + ); + +@@ -421,7 +421,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- uint16_t &group_id ++ int16_t &group_id + + ); + +@@ -462,7 +462,7 @@ std::string get_json_payload_for_groups_add_group_if_identifying_command( + */ + void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + nlohmann::json &jsn, +- uint16_t &group_id, ++ int16_t &group_id, + + std::string &group_name + +@@ -504,17 +504,17 @@ std::string get_json_payload_for_scenes_add_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_add_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + + std::vector &extension_field_sets, + +- uint8_t &transition_time100ms ++ int8_t &transition_time100ms + + ); + +@@ -544,9 +544,9 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -574,9 +574,9 @@ std::string get_json_payload_for_scenes_view_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_view_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -606,11 +606,11 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -642,9 +642,9 @@ std::string get_json_payload_for_scenes_remove_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_remove_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -674,9 +674,9 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -704,7 +704,7 @@ std::string get_json_payload_for_scenes_remove_all_scenes_command( + */ + void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + nlohmann::json &jsn, +- uint16_t &groupid ++ uint8_t * &groupid + + ); + +@@ -734,7 +734,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid ++ uint8_t * &groupid + + ); + +@@ -762,9 +762,9 @@ std::string get_json_payload_for_scenes_store_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_store_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -794,9 +794,9 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -824,11 +824,11 @@ std::string get_json_payload_for_scenes_recall_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_recall_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time ++ int16_t &transition_time + + ); + +@@ -856,7 +856,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_command( + */ + void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + nlohmann::json &jsn, +- uint16_t &groupid ++ uint8_t * &groupid + + ); + +@@ -886,11 +886,11 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t &capacity, ++ int8_t &capacity, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- std::vector &scene_list ++ std::vector &scene_list + + ); + +@@ -918,11 +918,11 @@ std::string get_json_payload_for_scenes_enhanced_add_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -956,9 +956,9 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -986,9 +986,9 @@ std::string get_json_payload_for_scenes_enhanced_view_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + nlohmann::json &jsn, +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid ++ int8_t &sceneid + + ); + +@@ -1018,11 +1018,11 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &groupid, ++ uint8_t * &groupid, + +- uint8_t &sceneid, ++ int8_t &sceneid, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + std::string &scene_name, + +@@ -1056,13 +1056,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + nlohmann::json &jsn, + uint8_t &mode, + +- uint16_t &group_identifier_from, ++ uint8_t * &group_identifier_from, + +- uint8_t &scene_identifier_from, ++ int8_t &scene_identifier_from, + +- uint16_t &group_identifier_to, ++ uint8_t * &group_identifier_to, + +- uint8_t &scene_identifier_to ++ int8_t &scene_identifier_to + + ); + +@@ -1092,9 +1092,9 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint16_t &group_identifier_from, ++ uint8_t * &group_identifier_from, + +- uint8_t &scene_identifier_from ++ int8_t &scene_identifier_from + + ); + +@@ -1175,7 +1175,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + nlohmann::json &jsn, + OffWithEffectEffectIdentifier &effect_identifier, + +- uint8_t &effect_variant ++ int8_t &effect_variant + + ); + +@@ -1218,9 +1218,9 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + nlohmann::json &jsn, + uint8_t &on_off_control, + +- uint16_t &on_time, ++ int16_t &on_time, + +- uint16_t &off_wait_time ++ int16_t &off_wait_time + + ); + +@@ -1260,9 +1260,9 @@ std::string get_json_payload_for_level_move_to_level_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_level( + nlohmann::json &jsn, +- uint8_t &level, ++ int8_t &level, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -1296,7 +1296,7 @@ void uic_mqtt_dotdot_parse_level_move( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -1330,9 +1330,9 @@ void uic_mqtt_dotdot_parse_level_step( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -1394,9 +1394,9 @@ std::string get_json_payload_for_level_move_to_level_with_on_off_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + nlohmann::json &jsn, +- uint8_t &level, ++ int8_t &level, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -1430,7 +1430,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -1464,9 +1464,9 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -1528,7 +1528,7 @@ std::string get_json_payload_for_level_move_to_closest_frequency_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + nlohmann::json &jsn, +- uint16_t &frequency ++ int16_t &frequency + + ); + +@@ -1570,7 +1570,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint16_t &cluster_identifier ++ uint8_t &cluster_identifier + + ); + +@@ -1600,7 +1600,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint16_t &cluster_identifier ++ uint8_t &cluster_identifier + + ); + +@@ -1645,9 +1645,9 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + + uint8_t &alarm_code, + +- uint16_t &cluster_identifier, ++ uint8_t &cluster_identifier, + +- uint32_t &time_stamp ++ int32_t &time_stamp + + ); + +@@ -1740,7 +1740,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + nlohmann::json &jsn, + bool &start_fast_polling, + +- uint16_t &fast_poll_timeout ++ int16_t &fast_poll_timeout + + ); + +@@ -1781,7 +1781,7 @@ std::string get_json_payload_for_poll_control_set_long_poll_interval_command( + */ + void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + nlohmann::json &jsn, +- uint32_t &new_long_poll_interval ++ int32_t &new_long_poll_interval + + ); + +@@ -1809,7 +1809,7 @@ std::string get_json_payload_for_poll_control_set_short_poll_interval_command( + */ + void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + nlohmann::json &jsn, +- uint16_t &new_short_poll_interval ++ int16_t &new_short_poll_interval + + ); + +@@ -2029,7 +2029,7 @@ std::string get_json_payload_for_door_lock_unlock_with_timeout_command( + */ + void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + nlohmann::json &jsn, +- uint16_t &timeout_in_seconds, ++ int16_t &timeout_in_seconds, + + std::string &pin_or_rfid_code + +@@ -2087,7 +2087,7 @@ std::string get_json_payload_for_door_lock_get_log_record_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_log_record( + nlohmann::json &jsn, +- uint16_t &log_index ++ int16_t &log_index + + ); + +@@ -2115,17 +2115,17 @@ std::string get_json_payload_for_door_lock_get_log_record_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + nlohmann::json &jsn, +- uint16_t &log_entryid, ++ int16_t &log_entryid, + +- uint32_t ×tamp, ++ int32_t ×tamp, + + GetLogRecordResponseEventType &event_type, + + DrlkOperEventSource &source_operation_event, + +- uint8_t &event_id_or_alarm_code, ++ int8_t &event_id_or_alarm_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin + +@@ -2155,7 +2155,7 @@ std::string get_json_payload_for_door_lock_set_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status, + +@@ -2217,7 +2217,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2245,7 +2245,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status, + +@@ -2279,7 +2279,7 @@ std::string get_json_payload_for_door_lock_clear_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2376,7 +2376,7 @@ std::string get_json_payload_for_door_lock_set_user_status_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_user_status( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status + +@@ -2434,7 +2434,7 @@ std::string get_json_payload_for_door_lock_get_user_status_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_status( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2462,7 +2462,7 @@ std::string get_json_payload_for_door_lock_get_user_status_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status + +@@ -2492,19 +2492,19 @@ std::string get_json_payload_for_door_lock_set_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid, ++ uint8_t * &userid, + + uint8_t &days_mask, + +- uint8_t &start_hour, ++ int8_t &start_hour, + +- uint8_t &start_minute, ++ int8_t &start_minute, + +- uint8_t &end_hour, ++ int8_t &end_hour, + +- uint8_t &end_minute ++ int8_t &end_minute + + ); + +@@ -2560,9 +2560,9 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2590,21 +2590,21 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_response_command + */ + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ int8_t &scheduleid, + +- uint16_t &userid, ++ int16_t &userid, + + zclStatus &status, + + uint8_t &days_mask, + +- uint8_t &start_hour, ++ int8_t &start_hour, + +- uint8_t &start_minute, ++ int8_t &start_minute, + +- uint8_t &end_hour, ++ int8_t &end_hour, + +- uint8_t &end_minute ++ int8_t &end_minute + + ); + +@@ -2632,9 +2632,9 @@ std::string get_json_payload_for_door_lock_clear_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2690,13 +2690,13 @@ std::string get_json_payload_for_door_lock_set_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid, ++ uint8_t * &userid, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time ++ int32_t &local_end_time + + ); + +@@ -2752,9 +2752,9 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2782,15 +2782,15 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_response_comman + */ + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ int8_t &scheduleid, + +- uint16_t &userid, ++ int16_t &userid, + + zclStatus &status, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time ++ int32_t &local_end_time + + ); + +@@ -2818,9 +2818,9 @@ std::string get_json_payload_for_door_lock_clear_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + nlohmann::json &jsn, +- uint8_t &scheduleid, ++ uint8_t * &scheduleid, + +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -2876,11 +2876,11 @@ std::string get_json_payload_for_door_lock_set_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid, ++ uint8_t * &holiday_scheduleid, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time, ++ int32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -2938,7 +2938,7 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid ++ uint8_t * &holiday_scheduleid + + ); + +@@ -2966,13 +2966,13 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_response_command + */ + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid, ++ int8_t &holiday_scheduleid, + + zclStatus &status, + +- uint32_t &local_start_time, ++ int32_t &local_start_time, + +- uint32_t &local_end_time, ++ int32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -3002,7 +3002,7 @@ std::string get_json_payload_for_door_lock_clear_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + nlohmann::json &jsn, +- uint8_t &holiday_scheduleid ++ uint8_t * &holiday_scheduleid + + ); + +@@ -3058,7 +3058,7 @@ std::string get_json_payload_for_door_lock_set_user_type_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_user_type( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkUserType &user_type + +@@ -3116,7 +3116,7 @@ std::string get_json_payload_for_door_lock_get_user_type_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_type( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -3144,7 +3144,7 @@ std::string get_json_payload_for_door_lock_get_user_type_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserType &user_type + +@@ -3174,7 +3174,7 @@ std::string get_json_payload_for_door_lock_set_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid, ++ uint8_t * &userid, + + DrlkSettableUserStatus &user_status, + +@@ -3236,7 +3236,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -3264,7 +3264,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + nlohmann::json &jsn, +- uint16_t &userid, ++ int16_t &userid, + + DrlkUserStatus &user_status, + +@@ -3298,7 +3298,7 @@ std::string get_json_payload_for_door_lock_clear_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + nlohmann::json &jsn, +- uint16_t &userid ++ uint8_t * &userid + + ); + +@@ -3397,11 +3397,11 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + nlohmann::json &jsn, + DataOperationTypeEnum &operation_type, + +- uint16_t &user_index, ++ int16_t &user_index, + + std::string &user_name, + +- uint32_t &user_uniqueid, ++ int32_t &user_uniqueid, + + DrlkSettableUserStatus &user_status, + +@@ -3435,7 +3435,7 @@ std::string get_json_payload_for_door_lock_get_user_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user( + nlohmann::json &jsn, +- uint16_t &user_index ++ int16_t &user_index + + ); + +@@ -3476,7 +3476,7 @@ std::string get_json_payload_for_door_lock_clear_user_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_user( + nlohmann::json &jsn, +- uint16_t &user_index ++ int16_t &user_index + + ); + +@@ -3508,11 +3508,11 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + + OperatingEventNotificationOperationEventCode &operation_event_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin, + +- uint32_t &local_time, ++ int32_t &local_time, + + std::string &data + +@@ -3546,7 +3546,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventCode &program_event_code, + +- uint16_t &userid, ++ int16_t &userid, + + std::string &pin, + +@@ -3554,7 +3554,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + DrlkUserStatus &user_status, + +- uint32_t &local_time, ++ int32_t &local_time, + + std::string &data + +@@ -3590,7 +3590,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + + std::string &credential_data, + +- uint16_t &user_index, ++ int16_t &user_index, + + DrlkSettableUserStatus &user_status, + +@@ -3783,7 +3783,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_value_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + nlohmann::json &jsn, +- uint16_t &lift_value ++ int16_t &lift_value + + ); + +@@ -3811,7 +3811,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_percentage_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + nlohmann::json &jsn, +- uint8_t &percentage_lift_value ++ int8_t &percentage_lift_value + + ); + +@@ -3839,7 +3839,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_value_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + nlohmann::json &jsn, +- uint16_t &tilt_value ++ int16_t &tilt_value + + ); + +@@ -3867,7 +3867,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_percentage_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + nlohmann::json &jsn, +- uint8_t &percentage_tilt_value ++ int8_t &percentage_tilt_value + + ); + +@@ -3907,7 +3907,7 @@ std::string get_json_payload_for_barrier_control_go_to_percent_command( + */ + void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + nlohmann::json &jsn, +- uint8_t &percent_open ++ int8_t &percent_open + + ); + +@@ -4070,17 +4070,17 @@ std::string get_json_payload_for_thermostat_get_relay_status_log_response_comman + */ + void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + nlohmann::json &jsn, +- uint16_t &time_of_day, ++ int16_t &time_of_day, + + uint8_t &relay_status, + + int16_t &local_temperature, + +- uint8_t &humidity_percentage, ++ int8_t &humidity_percentage, + + int16_t &set_point, + +- uint16_t &unread_entries ++ int16_t &unread_entries + + ); + +@@ -4212,11 +4212,11 @@ std::string get_json_payload_for_color_control_move_to_hue_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_hue( + nlohmann::json &jsn, +- uint8_t &hue, ++ int8_t &hue, + + CCDirection &direction, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4250,7 +4250,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -4284,9 +4284,9 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint8_t &transition_time, ++ int8_t &transition_time, + + uint8_t &options_mask, + +@@ -4318,9 +4318,9 @@ std::string get_json_payload_for_color_control_move_to_saturation_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + nlohmann::json &jsn, +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4354,7 +4354,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint8_t &rate, ++ int8_t &rate, + + uint8_t &options_mask, + +@@ -4388,9 +4388,9 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint8_t &step_size, ++ int8_t &step_size, + +- uint8_t &transition_time, ++ int8_t &transition_time, + + uint8_t &options_mask, + +@@ -4422,11 +4422,11 @@ std::string get_json_payload_for_color_control_move_to_hue_and_saturation_comman + */ + void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + nlohmann::json &jsn, +- uint8_t &hue, ++ int8_t &hue, + +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4458,11 +4458,11 @@ std::string get_json_payload_for_color_control_move_to_color_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_color( + nlohmann::json &jsn, +- uint16_t &colorx, ++ int16_t &colorx, + +- uint16_t &colory, ++ int16_t &colory, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4532,7 +4532,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + + int16_t &stepy, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4564,9 +4564,9 @@ std::string get_json_payload_for_color_control_move_to_color_temperature_command + */ + void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + nlohmann::json &jsn, +- uint16_t &color_temperature_mireds, ++ int16_t &color_temperature_mireds, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4598,11 +4598,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_command( + */ + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + nlohmann::json &jsn, +- uint16_t &enhanced_hue, ++ int16_t &enhanced_hue, + + CCDirection &direction, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4636,7 +4636,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint16_t &rate, ++ int16_t &rate, + + uint8_t &options_mask, + +@@ -4670,9 +4670,9 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint16_t &step_size, ++ int16_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4704,11 +4704,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_and_saturati + */ + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + nlohmann::json &jsn, +- uint16_t &enhanced_hue, ++ int16_t &enhanced_hue, + +- uint8_t &saturation, ++ int8_t &saturation, + +- uint16_t &transition_time, ++ int16_t &transition_time, + + uint8_t &options_mask, + +@@ -4746,9 +4746,9 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + + CCColorLoopDirection &direction, + +- uint16_t &time, ++ int16_t &time, + +- uint16_t &start_hue, ++ int16_t &start_hue, + + uint8_t &options_mask, + +@@ -4812,11 +4812,11 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- uint16_t &rate, ++ int16_t &rate, + +- uint16_t &color_temperature_minimum_mireds, ++ uint8_t * &color_temperature_minimum_mireds, + +- uint16_t &color_temperature_maximum_mireds, ++ uint8_t * &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -4850,13 +4850,13 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- uint16_t &step_size, ++ int16_t &step_size, + +- uint16_t &transition_time, ++ int16_t &transition_time, + +- uint16_t &color_temperature_minimum_mireds, ++ uint8_t * &color_temperature_minimum_mireds, + +- uint16_t &color_temperature_maximum_mireds, ++ uint8_t * &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -5082,7 +5082,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + nlohmann::json &jsn, + ZoneEnrollResponseEnrollResponseCode &enroll_response_code, + +- uint8_t &zoneid ++ int8_t &zoneid + + ); + +@@ -5114,9 +5114,9 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + + uint8_t &extended_status, + +- uint8_t &zoneid, ++ int8_t &zoneid, + +- uint16_t &delay ++ int16_t &delay + + ); + +@@ -5159,7 +5159,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + nlohmann::json &jsn, + IasZoneType &zone_type, + +- uint16_t &manufacturer_code ++ int16_t &manufacturer_code + + ); + +@@ -5187,9 +5187,9 @@ std::string get_json_payload_for_ias_zone_initiate_test_mode_command( + */ + void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + nlohmann::json &jsn, +- uint8_t &test_mode_duration, ++ int8_t &test_mode_duration, + +- uint8_t ¤t_zone_sensitivity_level ++ int8_t ¤t_zone_sensitivity_level + + ); + +@@ -5231,9 +5231,9 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + nlohmann::json &jsn, + uint8_t &siren_configuration, + +- uint16_t &warning_duration, ++ int16_t &warning_duration, + +- uint8_t &strobe_duty_cycle, ++ int8_t &strobe_duty_cycle, + + IaswdLevel &strobe_level + +@@ -5315,13 +5315,13 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + nlohmann::json &jsn, +- uint8_t &profile_count, ++ int8_t &profile_count, + + ProfileIntervalPeriod &profile_interval_period, + +- uint8_t &max_number_of_intervals, ++ int8_t &max_number_of_intervals, + +- std::vector &list_of_attributes ++ std::vector &list_of_attributes + + ); + +@@ -5362,17 +5362,17 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_response( + nlohmann::json &jsn, +- uint32_t &start_time, ++ uint8_t &start_time, + + GetMeasurementProfileResponseStatus &status, + + ProfileIntervalPeriod &profile_interval_period, + +- uint8_t &number_of_intervals_delivered, ++ int8_t &number_of_intervals_delivered, + +- uint16_t &attribute_id, ++ uint8_t &attribute_id, + +- std::vector &intervals ++ std::vector &intervals + + ); + +@@ -5400,11 +5400,11 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + nlohmann::json &jsn, +- uint16_t &attributeid, ++ uint8_t &attributeid, + +- uint32_t &start_time, ++ uint8_t &start_time, + +- uint8_t &number_of_intervals ++ int8_t &number_of_intervals + + ); + +@@ -5462,13 +5462,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + bool &transmission_successful, + +- uint16_t &transmission_time_ms, ++ int16_t &transmission_time_ms, + + int8_t &tx_powerd_bm, + +- uint8_t &tx_channel, ++ int8_t &tx_channel, + +- uint8_t &routing_attempts, ++ int8_t &routing_attempts, + + bool &route_changed, + +@@ -5482,7 +5482,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + int8_t &ackrssi, + +- uint8_t &ack_channel, ++ int8_t &ack_channel, + + std::string &last_route_failed_link_functionalunid, + +@@ -5626,7 +5626,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + + std::string &destination_unid, + +- uint8_t &destination_ep ++ int8_t &destination_ep + + ); + +@@ -5658,7 +5658,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + + std::string &destination_unid, + +- uint8_t &destination_ep ++ int8_t &destination_ep + + ); + +@@ -5824,7 +5824,7 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_com + */ + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + nlohmann::json &jsn, +- uint16_t ¶meter_id ++ int16_t ¶meter_id + + ); + +@@ -5865,7 +5865,7 @@ std::string get_json_payload_for_configuration_parameters_set_parameter_command( + */ + void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + nlohmann::json &jsn, +- uint16_t ¶meter_id, ++ int16_t ¶meter_id, + + int64_t &value + +@@ -5895,9 +5895,9 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_ran + */ + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + nlohmann::json &jsn, +- uint16_t &first_parameter_id, ++ int16_t &first_parameter_id, + +- uint16_t &last_parameter_id ++ int16_t &last_parameter_id + + ); + +@@ -5915,6 +5915,565 @@ void uic_mqtt_dotdot_parse_configuration_parameters_write_attributes( + ); + + ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential AddUser command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_add_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential AddUser command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_add_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ UserTypeEnum &user_type, ++ ++ bool &user_active_state, ++ ++ CredRule &credential_rule, ++ ++ std::string &user_name, ++ ++ int16_t &expiring_timeout_minutes, ++ ++ UserNameEncodingType &user_name_encoding ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential ModifyUser command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_modify_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential ModifyUser command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_modify_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ UserTypeEnum &user_type, ++ ++ bool &user_active_state, ++ ++ CredRule &credential_rule, ++ ++ std::string &user_name, ++ ++ int16_t &expiring_timeout_minutes, ++ ++ UserNameEncodingType &user_name_encoding ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteUser command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential DeleteUser command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_delete_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential AddCredential command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_add_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential AddCredential command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_add_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ std::string &credential_data ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential ModifyCredential command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_modify_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential ModifyCredential command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_modify_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ std::string &credential_data ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteCredential command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_credential_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential DeleteCredential command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_delete_credential( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteAllUsers command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_all_users_command( ++ ++); ++ ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteAllCredentials command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_all_credentials_command( ++ ++); ++ ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteAllCredentialsByType command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential DeleteAllCredentialsByType command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_by_type( ++ nlohmann::json &jsn, ++ CredType &credential_type ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteAllCredentialsForUser command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential DeleteAllCredentialsForUser command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeleteAllCredentialsForUserByType command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential DeleteAllCredentialsForUserByType command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential CredentialLearnStartAdd command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_credential_learn_start_add_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential CredentialLearnStartAdd command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ int8_t &credential_learn_timeout ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential CredentialLearnStartModify command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_credential_learn_start_modify_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential CredentialLearnStartModify command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid, ++ ++ CredType &credential_type, ++ ++ int16_t &credential_slot, ++ ++ int8_t &credential_learn_timeout ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential CredentialLearnStop command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_credential_learn_stop_command( ++ ++); ++ ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential CredentialAssociation command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_credential_association_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential CredentialAssociation command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_credential_association( ++ nlohmann::json &jsn, ++ CredType &credential_type, ++ ++ int16_t &source_user_uniqueid, ++ ++ int16_t &source_credential_slot, ++ ++ int16_t &destination_user_uniqueid, ++ ++ int16_t &destination_credential_slot ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential GetUserChecksum command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_get_user_checksum_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential GetUserChecksum command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_get_user_checksum( ++ nlohmann::json &jsn, ++ int16_t &user_uniqueid ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential GetCredentialChecksum command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_get_credential_checksum_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential GetCredentialChecksum command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_get_credential_checksum( ++ nlohmann::json &jsn, ++ CredType &credential_type ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential GetAllUsersChecksum command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_get_all_users_checksum_command( ++ ++); ++ ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential SetAdminPINCode command ++ * ++ * @param fields Struct pointer with the list of fields for the command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_set_admin_pin_code_command( ++ ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++); ++ ++ ++/** ++ * @brief JSON parser for UserCredential SetAdminPINCode command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_set_admin_pin_code( ++ nlohmann::json &jsn, ++ std::string &pin_code ++ ++); ++ ++ ++ ++/** ++ * @brief Private helper function that will create a JSON string based on the ++ * fields of a UserCredential DeactivateAdminPINCode command ++ * ++ * @returns std::string that contains JSON payload ++ */ ++std::string get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ++); ++ ++ ++ ++ ++/** ++ * @brief JSON parser for UserCredential WriteAttributes command arguments. ++ * ++ * Parse incoming JSON object to populate command arguments passed in by reference. ++ */ ++void uic_mqtt_dotdot_parse_user_credential_write_attributes( ++ nlohmann::json &jsn, ++ uic_mqtt_dotdot_user_credential_state_t &new_state, ++ uic_mqtt_dotdot_user_credential_updated_state_t &new_updated_state ++); ++ ++ + /** + * @brief Private helper function that will create a JSON string based on the + * fields of a ProtocolController/NetworkManagement Write command +@@ -6069,9 +6628,9 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + nlohmann::json &jsn, + SetpointType &type, + +- uint8_t &precision, ++ int8_t &precision, + +- uint8_t &scale, ++ int8_t &scale, + + int32_t &value + +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_generated_commands.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_generated_commands.cpp +index 6faf125b5f..523ffd0855 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_generated_commands.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_generated_commands.cpp +@@ -10915,6 +10915,746 @@ void uic_mqtt_dotdot_configuration_parameters_publish_generated_write_attributes + false); + } + ++/** ++ * @brief Publishes an incoming/generated AddUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_add_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/AddUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_user_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated ModifyUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/ModifyUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_user_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_user_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated AddCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/AddCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_add_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/AddCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_credential_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated ModifyCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/ModifyCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_modify_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/ModifyCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_credential_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteCredential command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteCredential ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_credential_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_credential_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteAllUsers command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllUsers ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_users_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllUsers"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_users_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentials command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentials ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentials"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsByType command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsByType ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsByType"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUser command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUser ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsForUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_delete_all_credentials_for_user_by_type_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStartAdd command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartAdd ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_add_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStartAdd"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_add_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStartModify command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStartModify ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_start_modify_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStartModify"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_modify_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated CredentialLearnStop command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialLearnStop ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_learn_stop_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/CredentialLearnStop"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_stop_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated CredentialAssociation command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/CredentialAssociation ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_credential_association_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/CredentialAssociation"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_association_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated GetUserChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetUserChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_user_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/GetUserChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_user_checksum_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated GetCredentialChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetCredentialChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_credential_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/GetCredentialChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_credential_checksum_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated GetAllUsersChecksum command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/GetAllUsersChecksum ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_get_all_users_checksum_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/GetAllUsersChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_all_users_checksum_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated SetAdminPINCode command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/SetAdminPINCode ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_set_admin_pin_code_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/SetAdminPINCode"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_set_admin_pin_code_command( ++ fields); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++/** ++ * @brief Publishes an incoming/generated DeactivateAdminPINCode command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/DeactivateAdminPINCode ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_deactivate_admin_pin_code_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/DeactivateAdminPINCode"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++ ++/** ++ * @brief Publishes an incoming/generated WriteAttributes command for ++ * the UserCredential cluster. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/GeneratedCommands/WriteAttributes ++ * ++ * @param unid The UNID of the node that sent us the command. ++ * ++ * @param endpoint The Endpoint ID of the node that sent us the command. ++ * ++ * @param attribute_values Values to assign to the attributes ++ * @param attribute_list List of attributes that are written ++ */ ++void uic_mqtt_dotdot_user_credential_publish_generated_write_attributes_command( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_user_credential_state_t attribute_values, ++ uic_mqtt_dotdot_user_credential_updated_state_t attribute_list ++){ ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(unid) + "/ep" + ++ std::to_string(endpoint) + "/"; ++ topic += "UserCredential/GeneratedCommands/WriteAttributes"; ++ ++ nlohmann::json json_object = nlohmann::json::object(); ++ ++ ++ // Payload contains data from end nodes, which we cannot control, thus we handle if there are non-utf8 characters ++ std::string payload = json_object.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace); ++ ++ // Publish our command ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ + /** + * @brief Publishes an incoming/generated Write command for + * the ProtocolController-NetworkManagement cluster. +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp +index 7c2fca7faf..91713c17a0 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp +@@ -354,6 +354,29 @@ static uic_mqtt_dotdot_by_group_configuration_parameters_discover_parameter_rang + static uic_mqtt_dotdot_by_group_configuration_parameters_write_attributes_callback_t uic_mqtt_dotdot_by_group_configuration_parameters_write_attributes_callback = nullptr; + + ++static uic_mqtt_dotdot_by_group_user_credential_add_user_callback_t uic_mqtt_dotdot_by_group_user_credential_add_user_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_t uic_mqtt_dotdot_by_group_user_credential_modify_user_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_user_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_t uic_mqtt_dotdot_by_group_user_credential_add_credential_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_t uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_t uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_t uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_t uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_t uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_t uic_mqtt_dotdot_by_group_user_credential_credential_association_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_t uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_t uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_t uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_t uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_t uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback = nullptr; ++static uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_t uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback = nullptr; ++ ++ + static uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback_t uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback = nullptr; + + +@@ -1835,6 +1858,135 @@ void uic_mqtt_dotdot_by_group_configuration_parameters_write_attributes_callback + + + ++// Callbacks setters ++ ++void uic_mqtt_dotdot_by_group_user_credential_add_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_add_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_add_user_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_modify_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_modify_user_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_user_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_add_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_add_credential_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_set(const uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_set(const uic_mqtt_dotdot_by_group_user_credential_credential_association_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_credential_association_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_set(const uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_set(const uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback = callback; ++} ++ ++ ++void uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_set(const uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback = callback; ++} ++ ++void uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_set( ++ const uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback_t callback) ++{ ++ uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback = callback; ++} ++ ++ ++ + // Callbacks setters + void uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback_set( + const uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback_t callback) +@@ -3060,7 +3212,7 @@ static void uic_mqtt_dotdot_on_by_group_groups_get_group_membership( + + + uic_mqtt_dotdot_groups_command_get_group_membership_fields_t fields; +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -3149,7 +3301,7 @@ static void uic_mqtt_dotdot_on_by_group_groups_get_group_membership_response( + + + uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t fields; +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -4876,7 +5028,7 @@ static void uic_mqtt_dotdot_on_by_group_scenes_get_scene_membership_response( + + + uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t fields; +- std::vector scene_list; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -21348,7 +21500,7 @@ static void uic_mqtt_dotdot_on_by_group_electrical_measurement_get_profile_info_ + + + uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t fields; +- std::vector list_of_attributes; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -21529,7 +21681,7 @@ static void uic_mqtt_dotdot_on_by_group_electrical_measurement_get_measurement_p + + + uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t fields; +- std::vector intervals; ++ std::vector intervals; + + + nlohmann::json jsn; +@@ -22908,98 +23060,13 @@ sl_status_t uic_mqtt_dotdot_by_group_configuration_parameters_init() + + + +-static void uic_mqtt_dotdot_on_by_group_descriptor_WriteAttributes( +- const char *topic, +- const char *message, +- const size_t message_length) +-{ +- +- if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback == nullptr)) { +- return; +- } +- if (message_length == 0) { +- return; +- } +- +- dotdot_group_id_t group_id = 0U; +- if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { +- sl_log_debug(LOG_TAG, +- "Failed to parse GroupId from topic %s. Ignoring", +- topic); +- return; +- } +- +- if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_descriptor_write_attributes_callback().empty())) { +- try { +- group_dispatch_callback(group_id, +- "Descriptor", +- "WriteAttributes", +- message, +- message_length, +- uic_mqtt_dotdot_on_descriptor_WriteAttributes); +- +- } catch (...) { +- sl_log_debug(LOG_TAG, "Descriptor: Unable to parse JSON payload.\n"); +- return; +- } +- } else if (uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback != nullptr) { +- +- uic_mqtt_dotdot_descriptor_state_t new_state = {}; +- uic_mqtt_dotdot_descriptor_updated_state_t new_updated_state = {}; +- +- +- nlohmann::json jsn; +- try { +- jsn = nlohmann::json::parse(std::string(message)); +- +- uic_mqtt_dotdot_parse_descriptor_write_attributes( +- jsn, +- new_state, +- new_updated_state +- ); +- } catch (const nlohmann::json::parse_error& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "Descriptor", "WriteAttributes"); +- return; +- } catch (const nlohmann::json::exception& e) { +- // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", e.what()); +- return; +- } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", ""); +- return; +- } +- +- uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback( +- group_id, +- new_state, +- new_updated_state +- ); +- } +-} +- +-sl_status_t uic_mqtt_dotdot_by_group_descriptor_init() +-{ +- std::string subscription_topic; +- const std::string topic_bygroup = TOPIC_BY_GROUP_PREFIX; +- if(uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback) { +- subscription_topic = topic_bygroup + "Descriptor/Commands/WriteAttributes"; +- uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_descriptor_WriteAttributes); +- } +- +- return SL_STATUS_OK; +-} +- +- +- +- +-// Callback function for incoming publications on ucl/by-group/+/UnifyFanControl/Commands/SetFanMode +-static void uic_mqtt_dotdot_on_by_group_unify_fan_control_set_fan_mode( ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/AddUser ++static void uic_mqtt_dotdot_on_by_group_user_credential_add_user( + const char *topic, + const char *message, + const size_t message_length) + { +- if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback == nullptr)) { ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_add_user_callback == nullptr)) { + return; + } + if (message_length == 0) { +@@ -23016,75 +23083,113 @@ static void uic_mqtt_dotdot_on_by_group_unify_fan_control_set_fan_mode( + + // Pass to command-specific callback if set. Otherwise, pass to + // group-dispatch callback +- if (uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback != nullptr) { ++ if (uic_mqtt_dotdot_by_group_user_credential_add_user_callback != nullptr) { + + +- uic_mqtt_dotdot_unify_fan_control_command_set_fan_mode_fields_t fields; +- ++ uic_mqtt_dotdot_user_credential_command_add_user_fields_t fields; ++ std::string user_name; ++ + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + + +- uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ uic_mqtt_dotdot_parse_user_credential_add_user( + jsn, +- fields.fan_mode ++ fields.user_uniqueid, ++ ++ fields.user_type, ++ ++ fields.user_active_state, ++ ++ fields.credential_rule, ++ ++ user_name, ++ ++ fields.expiring_timeout_minutes, ++ ++ fields.user_name_encoding + ); + + // Populate list fields from vector or string types ++ fields.user_name = user_name.c_str(); + + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "AddUser"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddUser", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddUser", ""); + return; + } + +- uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback( ++ uic_mqtt_dotdot_by_group_user_credential_add_user_callback( + group_id, + &fields + ); +- } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback().empty())) { ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_add_user_callback().empty())) { + // group-dispatch callback only called if the command-specific by-unid + // callback is set + try { + nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- if (jsn.find("FanMode") == jsn.end()) { +- sl_log_debug(LOG_TAG, "UnifyFanControl::SetFanMode: Missing command-argument: FanMode\n"); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("UserType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: UserType\n"); ++ return; ++ } ++ if (jsn.find("UserActiveState") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: UserActiveState\n"); ++ return; ++ } ++ if (jsn.find("CredentialRule") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: CredentialRule\n"); ++ return; ++ } ++ if (jsn.find("UserName") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: UserName\n"); ++ return; ++ } ++ if (jsn.find("ExpiringTimeoutMinutes") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: ExpiringTimeoutMinutes\n"); ++ return; ++ } ++ if (jsn.find("UserNameEncoding") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddUser: Missing command-argument: UserNameEncoding\n"); + return; + } + + group_dispatch_callback( + group_id, +- "UnifyFanControl", +- "SetFanMode", ++ "UserCredential", ++ "AddUser", + message, + message_length, +- uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode); ++ uic_mqtt_dotdot_on_user_credential_add_user); + + } catch (...) { +- sl_log_debug(LOG_TAG, "SetFanMode: Unable to parse JSON payload.\n"); ++ sl_log_debug(LOG_TAG, "AddUser: Unable to parse JSON payload.\n"); + return; + } + } + + } + +-// Callback function for incoming publications on ucl/by-group/+/UnifyFanControl/Commands/TurnOff +-static void uic_mqtt_dotdot_on_by_group_unify_fan_control_turn_off( ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/ModifyUser ++static void uic_mqtt_dotdot_on_by_group_user_credential_modify_user( + const char *topic, + const char *message, + const size_t message_length) + { +- if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback == nullptr)) { ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_modify_user_callback == nullptr)) { + return; + } + if (message_length == 0) { +@@ -23101,50 +23206,2103 @@ static void uic_mqtt_dotdot_on_by_group_unify_fan_control_turn_off( + + // Pass to command-specific callback if set. Otherwise, pass to + // group-dispatch callback +- if (uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback != nullptr) { ++ if (uic_mqtt_dotdot_by_group_user_credential_modify_user_callback != nullptr) { + + ++ uic_mqtt_dotdot_user_credential_command_modify_user_fields_t fields; ++ std::string user_name; ++ + + nlohmann::json jsn; + try { + jsn = nlohmann::json::parse(std::string(message)); + + ++ uic_mqtt_dotdot_parse_user_credential_modify_user( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.user_type, ++ ++ fields.user_active_state, ++ ++ fields.credential_rule, ++ ++ user_name, ++ ++ fields.expiring_timeout_minutes, ++ ++ fields.user_name_encoding ++ ); + + // Populate list fields from vector or string types ++ fields.user_name = user_name.c_str(); + + + } catch (const nlohmann::json::parse_error& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyUser"); + return; + } catch (const nlohmann::json::exception& e) { + // Catch JSON object field parsing errors +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", e.what()); + return; + } catch (const std::exception& e) { +- sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyUser", ""); + return; + } + +- uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback( +- group_id ++ uic_mqtt_dotdot_by_group_user_credential_modify_user_callback( ++ group_id, ++ &fields + ); +- } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_unify_fan_control_turn_off_callback().empty())) { ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_modify_user_callback().empty())) { + // group-dispatch callback only called if the command-specific by-unid + // callback is set + try { + nlohmann::json jsn = nlohmann::json::parse(std::string(message)); +- +- group_dispatch_callback( +- group_id, +- "UnifyFanControl", +- "TurnOff", +- message, +- message_length, +- uic_mqtt_dotdot_on_unify_fan_control_turn_off); +- +- } catch (...) { ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("UserType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: UserType\n"); ++ return; ++ } ++ if (jsn.find("UserActiveState") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: UserActiveState\n"); ++ return; ++ } ++ if (jsn.find("CredentialRule") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: CredentialRule\n"); ++ return; ++ } ++ if (jsn.find("UserName") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: UserName\n"); ++ return; ++ } ++ if (jsn.find("ExpiringTimeoutMinutes") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: ExpiringTimeoutMinutes\n"); ++ return; ++ } ++ if (jsn.find("UserNameEncoding") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyUser: Missing command-argument: UserNameEncoding\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "ModifyUser", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_modify_user); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "ModifyUser: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteUser ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_user_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_user_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_delete_user_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_user( ++ jsn, ++ fields.user_uniqueid ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteUser", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_user_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_user_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteUser: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteUser", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_user); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteUser: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/AddCredential ++static void uic_mqtt_dotdot_on_by_group_user_credential_add_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_add_credential_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_add_credential_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_add_credential_fields_t fields; ++ std::string credential_data; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_add_credential( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type, ++ ++ fields.credential_slot, ++ ++ credential_data ++ ); ++ ++ // Populate list fields from vector or string types ++ fields.credential_data = credential_data.c_str(); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "AddCredential"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "AddCredential", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_add_credential_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_add_credential_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddCredential: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddCredential: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("CredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddCredential: Missing command-argument: CredentialSlot\n"); ++ return; ++ } ++ if (jsn.find("CredentialData") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::AddCredential: Missing command-argument: CredentialData\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "AddCredential", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_add_credential); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "AddCredential: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/ModifyCredential ++static void uic_mqtt_dotdot_on_by_group_user_credential_modify_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t fields; ++ std::string credential_data; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_modify_credential( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type, ++ ++ fields.credential_slot, ++ ++ credential_data ++ ); ++ ++ // Populate list fields from vector or string types ++ fields.credential_data = credential_data.c_str(); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "ModifyCredential"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "ModifyCredential", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_modify_credential_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyCredential: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyCredential: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("CredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyCredential: Missing command-argument: CredentialSlot\n"); ++ return; ++ } ++ if (jsn.find("CredentialData") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::ModifyCredential: Missing command-argument: CredentialData\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "ModifyCredential", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_modify_credential); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "ModifyCredential: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteCredential ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_credential( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_credential( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type, ++ ++ fields.credential_slot ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteCredential"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteCredential", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_credential_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteCredential: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteCredential: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("CredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteCredential: Missing command-argument: CredentialSlot\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteCredential", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_credential); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteCredential: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteAllUsers ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_all_users( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllUsers"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllUsers", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_all_users_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteAllUsers", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_all_users); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteAllUsers: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteAllCredentials ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentials"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentials", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteAllCredentials", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_all_credentials); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteAllCredentials: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsByType ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_by_type( ++ jsn, ++ fields.credential_type ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsByType"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsByType", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteAllCredentialsByType: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteAllCredentialsByType", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_all_credentials_by_type); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteAllCredentialsByType: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsForUser ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( ++ jsn, ++ fields.user_uniqueid ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUser"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUser", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteAllCredentialsForUser: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteAllCredentialsForUser", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteAllCredentialsForUser: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsForUserByType ++static void uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user_by_type( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeleteAllCredentialsForUserByType"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeleteAllCredentialsForUserByType", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteAllCredentialsForUserByType: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::DeleteAllCredentialsForUserByType: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeleteAllCredentialsForUserByType", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user_by_type); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeleteAllCredentialsForUserByType: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/CredentialLearnStartAdd ++static void uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_add( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type, ++ ++ fields.credential_slot, ++ ++ fields.credential_learn_timeout ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartAdd"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartAdd", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartAdd: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartAdd: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("CredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartAdd: Missing command-argument: CredentialSlot\n"); ++ return; ++ } ++ if (jsn.find("CredentialLearnTimeout") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartAdd: Missing command-argument: CredentialLearnTimeout\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "CredentialLearnStartAdd", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_credential_learn_start_add); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "CredentialLearnStartAdd: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/CredentialLearnStartModify ++static void uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_modify( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( ++ jsn, ++ fields.user_uniqueid, ++ ++ fields.credential_type, ++ ++ fields.credential_slot, ++ ++ fields.credential_learn_timeout ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStartModify"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStartModify", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartModify: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartModify: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("CredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartModify: Missing command-argument: CredentialSlot\n"); ++ return; ++ } ++ if (jsn.find("CredentialLearnTimeout") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialLearnStartModify: Missing command-argument: CredentialLearnTimeout\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "CredentialLearnStartModify", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_credential_learn_start_modify); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "CredentialLearnStartModify: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/CredentialLearnStop ++static void uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_stop( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialLearnStop"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialLearnStop", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "CredentialLearnStop", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_credential_learn_stop); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "CredentialLearnStop: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/CredentialAssociation ++static void uic_mqtt_dotdot_on_by_group_user_credential_credential_association( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_credential_association_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_association_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_credential_association_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_credential_association( ++ jsn, ++ fields.credential_type, ++ ++ fields.source_user_uniqueid, ++ ++ fields.source_credential_slot, ++ ++ fields.destination_user_uniqueid, ++ ++ fields.destination_credential_slot ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "CredentialAssociation"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "CredentialAssociation", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_credential_association_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_credential_association_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialAssociation: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ if (jsn.find("SourceUserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialAssociation: Missing command-argument: SourceUserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("SourceCredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialAssociation: Missing command-argument: SourceCredentialSlot\n"); ++ return; ++ } ++ if (jsn.find("DestinationUserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialAssociation: Missing command-argument: DestinationUserUniqueID\n"); ++ return; ++ } ++ if (jsn.find("DestinationCredentialSlot") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::CredentialAssociation: Missing command-argument: DestinationCredentialSlot\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "CredentialAssociation", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_credential_association); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "CredentialAssociation: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/GetUserChecksum ++static void uic_mqtt_dotdot_on_by_group_user_credential_get_user_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_get_user_checksum( ++ jsn, ++ fields.user_uniqueid ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetUserChecksum"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetUserChecksum", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_get_user_checksum_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("UserUniqueID") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::GetUserChecksum: Missing command-argument: UserUniqueID\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "GetUserChecksum", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_get_user_checksum); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "GetUserChecksum: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/GetCredentialChecksum ++static void uic_mqtt_dotdot_on_by_group_user_credential_get_credential_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_get_credential_checksum( ++ jsn, ++ fields.credential_type ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetCredentialChecksum"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetCredentialChecksum", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("CredentialType") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::GetCredentialChecksum: Missing command-argument: CredentialType\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "GetCredentialChecksum", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_get_credential_checksum); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "GetCredentialChecksum: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/GetAllUsersChecksum ++static void uic_mqtt_dotdot_on_by_group_user_credential_get_all_users_checksum( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "GetAllUsersChecksum"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "GetAllUsersChecksum", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "GetAllUsersChecksum", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_get_all_users_checksum); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "GetAllUsersChecksum: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/SetAdminPINCode ++static void uic_mqtt_dotdot_on_by_group_user_credential_set_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t fields; ++ std::string pin_code; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_user_credential_set_admin_pin_code( ++ jsn, ++ pin_code ++ ); ++ ++ // Populate list fields from vector or string types ++ fields.pin_code = pin_code.c_str(); ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "SetAdminPINCode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "SetAdminPINCode", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("PINCode") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UserCredential::SetAdminPINCode: Missing command-argument: PINCode\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "SetAdminPINCode", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_set_admin_pin_code); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "SetAdminPINCode: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UserCredential/Commands/DeactivateAdminPINCode ++static void uic_mqtt_dotdot_on_by_group_user_credential_deactivate_admin_pin_code( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "DeactivateAdminPINCode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "DeactivateAdminPINCode", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UserCredential", ++ "DeactivateAdminPINCode", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_deactivate_admin_pin_code); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "DeactivateAdminPINCode: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++static void uic_mqtt_dotdot_on_by_group_user_credential_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_user_credential_write_attributes_callback().empty())) { ++ try { ++ group_dispatch_callback(group_id, ++ "UserCredential", ++ "WriteAttributes", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_user_credential_WriteAttributes); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "UserCredential: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } else if (uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback != nullptr) { ++ ++ uic_mqtt_dotdot_user_credential_state_t new_state = {}; ++ uic_mqtt_dotdot_user_credential_updated_state_t new_updated_state = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_user_credential_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UserCredential", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UserCredential", "WriteAttributes", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback( ++ group_id, ++ new_state, ++ new_updated_state ++ ); ++ } ++} ++ ++sl_status_t uic_mqtt_dotdot_by_group_user_credential_init() ++{ ++ std::string subscription_topic; ++ const std::string topic_bygroup = TOPIC_BY_GROUP_PREFIX; ++ if(uic_mqtt_dotdot_by_group_user_credential_write_attributes_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_WriteAttributes); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_add_user_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/AddUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_add_user); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_modify_user_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/ModifyUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_modify_user); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_user_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_user); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_add_credential_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/AddCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_add_credential); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_modify_credential_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/ModifyCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_modify_credential); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_credential_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteCredential"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_credential); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_users_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteAllUsers"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_all_users); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteAllCredentials"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_by_type_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteAllCredentialsByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_by_type); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteAllCredentialsForUser"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_delete_all_credentials_for_user_by_type_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeleteAllCredentialsForUserByType"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user_by_type); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_add_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/CredentialLearnStartAdd"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_add); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_start_modify_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/CredentialLearnStartModify"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_modify); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_learn_stop_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/CredentialLearnStop"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_stop); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_credential_association_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/CredentialAssociation"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_credential_association); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_get_user_checksum_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/GetUserChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_get_user_checksum); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_get_credential_checksum_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/GetCredentialChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_get_credential_checksum); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_get_all_users_checksum_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/GetAllUsersChecksum"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_get_all_users_checksum); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_set_admin_pin_code_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/SetAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_set_admin_pin_code); ++ } ++ if (uic_mqtt_dotdot_by_group_user_credential_deactivate_admin_pin_code_callback) { ++ subscription_topic = topic_bygroup + "UserCredential/Commands/DeactivateAdminPINCode"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_user_credential_deactivate_admin_pin_code); ++ } ++ ++ return SL_STATUS_OK; ++} ++ ++ ++ ++ ++static void uic_mqtt_dotdot_on_by_group_descriptor_WriteAttributes( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_descriptor_write_attributes_callback().empty())) { ++ try { ++ group_dispatch_callback(group_id, ++ "Descriptor", ++ "WriteAttributes", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_descriptor_WriteAttributes); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "Descriptor: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } else if (uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback != nullptr) { ++ ++ uic_mqtt_dotdot_descriptor_state_t new_state = {}; ++ uic_mqtt_dotdot_descriptor_updated_state_t new_updated_state = {}; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ uic_mqtt_dotdot_parse_descriptor_write_attributes( ++ jsn, ++ new_state, ++ new_updated_state ++ ); ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "Descriptor", "WriteAttributes"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "Descriptor", "WriteAttributes", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback( ++ group_id, ++ new_state, ++ new_updated_state ++ ); ++ } ++} ++ ++sl_status_t uic_mqtt_dotdot_by_group_descriptor_init() ++{ ++ std::string subscription_topic; ++ const std::string topic_bygroup = TOPIC_BY_GROUP_PREFIX; ++ if(uic_mqtt_dotdot_by_group_descriptor_write_attributes_callback) { ++ subscription_topic = topic_bygroup + "Descriptor/Commands/WriteAttributes"; ++ uic_mqtt_subscribe(subscription_topic.c_str(), uic_mqtt_dotdot_on_by_group_descriptor_WriteAttributes); ++ } ++ ++ return SL_STATUS_OK; ++} ++ ++ ++ ++ ++// Callback function for incoming publications on ucl/by-group/+/UnifyFanControl/Commands/SetFanMode ++static void uic_mqtt_dotdot_on_by_group_unify_fan_control_set_fan_mode( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback != nullptr) { ++ ++ ++ uic_mqtt_dotdot_unify_fan_control_command_set_fan_mode_fields_t fields; ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ uic_mqtt_dotdot_parse_unify_fan_control_set_fan_mode( ++ jsn, ++ fields.fan_mode ++ ); ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "SetFanMode"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "SetFanMode", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_unify_fan_control_set_fan_mode_callback( ++ group_id, ++ &fields ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ if (jsn.find("FanMode") == jsn.end()) { ++ sl_log_debug(LOG_TAG, "UnifyFanControl::SetFanMode: Missing command-argument: FanMode\n"); ++ return; ++ } ++ ++ group_dispatch_callback( ++ group_id, ++ "UnifyFanControl", ++ "SetFanMode", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_unify_fan_control_set_fan_mode); ++ ++ } catch (...) { ++ sl_log_debug(LOG_TAG, "SetFanMode: Unable to parse JSON payload.\n"); ++ return; ++ } ++ } ++ ++} ++ ++// Callback function for incoming publications on ucl/by-group/+/UnifyFanControl/Commands/TurnOff ++static void uic_mqtt_dotdot_on_by_group_unify_fan_control_turn_off( ++ const char *topic, ++ const char *message, ++ const size_t message_length) ++{ ++ if ((group_dispatch_callback == nullptr) && (uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback == nullptr)) { ++ return; ++ } ++ if (message_length == 0) { ++ return; ++ } ++ ++ dotdot_group_id_t group_id = 0U; ++ if(!uic_dotdot_mqtt::parse_topic_group_id(topic,group_id)) { ++ sl_log_debug(LOG_TAG, ++ "Failed to parse GroupId from topic %s. Ignoring", ++ topic); ++ return; ++ } ++ ++ // Pass to command-specific callback if set. Otherwise, pass to ++ // group-dispatch callback ++ if (uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback != nullptr) { ++ ++ ++ ++ nlohmann::json jsn; ++ try { ++ jsn = nlohmann::json::parse(std::string(message)); ++ ++ ++ ++ // Populate list fields from vector or string types ++ ++ ++ } catch (const nlohmann::json::parse_error& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_PARSE_FAIL, "UnifyFanControl", "TurnOff"); ++ return; ++ } catch (const nlohmann::json::exception& e) { ++ // Catch JSON object field parsing errors ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", e.what()); ++ return; ++ } catch (const std::exception& e) { ++ sl_log_debug(LOG_TAG, LOG_FMT_JSON_ERROR, "UnifyFanControl", "TurnOff", ""); ++ return; ++ } ++ ++ uic_mqtt_dotdot_by_group_unify_fan_control_turn_off_callback( ++ group_id ++ ); ++ } else if ((group_dispatch_callback != nullptr) && (!get_uic_mqtt_dotdot_unify_fan_control_turn_off_callback().empty())) { ++ // group-dispatch callback only called if the command-specific by-unid ++ // callback is set ++ try { ++ nlohmann::json jsn = nlohmann::json::parse(std::string(message)); ++ ++ group_dispatch_callback( ++ group_id, ++ "UnifyFanControl", ++ "TurnOff", ++ message, ++ message_length, ++ uic_mqtt_dotdot_on_unify_fan_control_turn_off); ++ ++ } catch (...) { + sl_log_debug(LOG_TAG, "TurnOff: Unable to parse JSON payload.\n"); + return; + } +@@ -23882,6 +26040,28 @@ void uic_mqtt_dotdot_set_group_dispatch_callback(group_dispatch_t callback) + uic_mqtt_subscribe("ucl/by-group/+/ConfigurationParameters/Commands/SetParameter", uic_mqtt_dotdot_on_by_group_configuration_parameters_set_parameter); + uic_mqtt_subscribe("ucl/by-group/+/ConfigurationParameters/Commands/DiscoverParameterRange", uic_mqtt_dotdot_on_by_group_configuration_parameters_discover_parameter_range); + ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/WriteAttributes", uic_mqtt_dotdot_on_by_group_user_credential_WriteAttributes); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/AddUser", uic_mqtt_dotdot_on_by_group_user_credential_add_user); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/ModifyUser", uic_mqtt_dotdot_on_by_group_user_credential_modify_user); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteUser", uic_mqtt_dotdot_on_by_group_user_credential_delete_user); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/AddCredential", uic_mqtt_dotdot_on_by_group_user_credential_add_credential); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/ModifyCredential", uic_mqtt_dotdot_on_by_group_user_credential_modify_credential); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteCredential", uic_mqtt_dotdot_on_by_group_user_credential_delete_credential); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteAllUsers", uic_mqtt_dotdot_on_by_group_user_credential_delete_all_users); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteAllCredentials", uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsByType", uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_by_type); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsForUser", uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeleteAllCredentialsForUserByType", uic_mqtt_dotdot_on_by_group_user_credential_delete_all_credentials_for_user_by_type); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/CredentialLearnStartAdd", uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_add); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/CredentialLearnStartModify", uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_start_modify); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/CredentialLearnStop", uic_mqtt_dotdot_on_by_group_user_credential_credential_learn_stop); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/CredentialAssociation", uic_mqtt_dotdot_on_by_group_user_credential_credential_association); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/GetUserChecksum", uic_mqtt_dotdot_on_by_group_user_credential_get_user_checksum); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/GetCredentialChecksum", uic_mqtt_dotdot_on_by_group_user_credential_get_credential_checksum); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/GetAllUsersChecksum", uic_mqtt_dotdot_on_by_group_user_credential_get_all_users_checksum); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/SetAdminPINCode", uic_mqtt_dotdot_on_by_group_user_credential_set_admin_pin_code); ++ uic_mqtt_subscribe("ucl/by-group/+/UserCredential/Commands/DeactivateAdminPINCode", uic_mqtt_dotdot_on_by_group_user_credential_deactivate_admin_pin_code); ++ + uic_mqtt_subscribe("ucl/by-group/+/Descriptor/Commands/WriteAttributes", uic_mqtt_dotdot_on_by_group_descriptor_WriteAttributes); + + uic_mqtt_subscribe("ucl/by-group/+/UnifyFanControl/Commands/WriteAttributes", uic_mqtt_dotdot_on_by_group_unify_fan_control_WriteAttributes); +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_helpers.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_helpers.cpp +index c1531c376c..620772af1c 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_helpers.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_helpers.cpp +@@ -1397,6 +1397,100 @@ uint32_t commissioning_startup_control_get_enum_value_number(const std::string & + return std::numeric_limits::max(); + } + ++// Enum to string map for CredRule ++const std::map cred_rule_enum_id_to_string_map { ++ { 1, "Single" }, ++ { 2, "Dual" }, ++ { 3, "Triple" }, ++}; ++ ++// String to enum map for CredRule ++const std::map cred_rule_enum_string_to_id_map { ++ { "Single", 1 }, ++ { "Dual", 2 }, ++ { "Triple", 3 }, ++}; ++ ++std::string cred_rule_get_enum_value_name( ++ uint32_t value) ++{ ++ auto it = cred_rule_enum_id_to_string_map.find(value); ++ if (it != cred_rule_enum_id_to_string_map.end()){ ++ return it->second; ++ } ++ ++ // No known name value is set for this field. ++ // Set it to a string version of the value. ++ return std::to_string(value); ++} ++ ++uint32_t cred_rule_get_enum_value_number(const std::string &str) ++{ ++ auto it = cred_rule_enum_string_to_id_map.find(str); ++ if (it != cred_rule_enum_string_to_id_map.end()){ ++ return it->second; ++ } ++ ++ // No known numeric value is set for this string. ++ // Return UINT32_MAX to indicate an error. ++ return std::numeric_limits::max(); ++} ++ ++// Enum to string map for CredType ++const std::map cred_type_enum_id_to_string_map { ++ { 1, "PINCode" }, ++ { 2, "Password" }, ++ { 3, "RFIDCode" }, ++ { 4, "BLE" }, ++ { 5, "NFC" }, ++ { 6, "UWB" }, ++ { 7, "EyeBiometric" }, ++ { 8, "FaceBiometric" }, ++ { 9, "FingerBiometric" }, ++ { 10, "HandBiometric" }, ++ { 11, "UnspecifiedBiometric" }, ++}; ++ ++// String to enum map for CredType ++const std::map cred_type_enum_string_to_id_map { ++ { "PINCode", 1 }, ++ { "Password", 2 }, ++ { "RFIDCode", 3 }, ++ { "BLE", 4 }, ++ { "NFC", 5 }, ++ { "UWB", 6 }, ++ { "EyeBiometric", 7 }, ++ { "FaceBiometric", 8 }, ++ { "FingerBiometric", 9 }, ++ { "HandBiometric", 10 }, ++ { "UnspecifiedBiometric", 11 }, ++}; ++ ++std::string cred_type_get_enum_value_name( ++ uint32_t value) ++{ ++ auto it = cred_type_enum_id_to_string_map.find(value); ++ if (it != cred_type_enum_id_to_string_map.end()){ ++ return it->second; ++ } ++ ++ // No known name value is set for this field. ++ // Set it to a string version of the value. ++ return std::to_string(value); ++} ++ ++uint32_t cred_type_get_enum_value_number(const std::string &str) ++{ ++ auto it = cred_type_enum_string_to_id_map.find(str); ++ if (it != cred_type_enum_string_to_id_map.end()){ ++ return it->second; ++ } ++ ++ // No known numeric value is set for this string. ++ // Return UINT32_MAX to indicate an error. ++ return std::numeric_limits::max(); ++} ++ + // Enum to string map for CredentialRuleEnum + const std::map credential_rule_enum_enum_id_to_string_map { + { 0, "Single" }, +@@ -5379,6 +5473,135 @@ uint32_t unify_thermostat_thermostat_mode_get_enum_value_number(const std::strin + return std::numeric_limits::max(); + } + ++// Enum to string map for UserModifierType ++const std::map user_modifier_type_enum_id_to_string_map { ++ { 0, "DNE" }, ++ { 1, "Unknown" }, ++ { 2, "Z-Wave" }, ++ { 3, "Locally" }, ++ { 4, "MobileAppOrOtherIoT" }, ++}; ++ ++// String to enum map for UserModifierType ++const std::map user_modifier_type_enum_string_to_id_map { ++ { "DNE", 0 }, ++ { "Unknown", 1 }, ++ { "Z-Wave", 2 }, ++ { "Locally", 3 }, ++ { "MobileAppOrOtherIoT", 4 }, ++}; ++ ++std::string user_modifier_type_get_enum_value_name( ++ uint32_t value) ++{ ++ auto it = user_modifier_type_enum_id_to_string_map.find(value); ++ if (it != user_modifier_type_enum_id_to_string_map.end()){ ++ return it->second; ++ } ++ ++ // No known name value is set for this field. ++ // Set it to a string version of the value. ++ return std::to_string(value); ++} ++ ++uint32_t user_modifier_type_get_enum_value_number(const std::string &str) ++{ ++ auto it = user_modifier_type_enum_string_to_id_map.find(str); ++ if (it != user_modifier_type_enum_string_to_id_map.end()){ ++ return it->second; ++ } ++ ++ // No known numeric value is set for this string. ++ // Return UINT32_MAX to indicate an error. ++ return std::numeric_limits::max(); ++} ++ ++// Enum to string map for UserNameEncodingType ++const std::map user_name_encoding_type_enum_id_to_string_map { ++ { 0, "ASCII" }, ++ { 1, "OEMExtendedASCII" }, ++ { 2, "UTF-16" }, ++}; ++ ++// String to enum map for UserNameEncodingType ++const std::map user_name_encoding_type_enum_string_to_id_map { ++ { "ASCII", 0 }, ++ { "OEMExtendedASCII", 1 }, ++ { "UTF-16", 2 }, ++}; ++ ++std::string user_name_encoding_type_get_enum_value_name( ++ uint32_t value) ++{ ++ auto it = user_name_encoding_type_enum_id_to_string_map.find(value); ++ if (it != user_name_encoding_type_enum_id_to_string_map.end()){ ++ return it->second; ++ } ++ ++ // No known name value is set for this field. ++ // Set it to a string version of the value. ++ return std::to_string(value); ++} ++ ++uint32_t user_name_encoding_type_get_enum_value_number(const std::string &str) ++{ ++ auto it = user_name_encoding_type_enum_string_to_id_map.find(str); ++ if (it != user_name_encoding_type_enum_string_to_id_map.end()){ ++ return it->second; ++ } ++ ++ // No known numeric value is set for this string. ++ // Return UINT32_MAX to indicate an error. ++ return std::numeric_limits::max(); ++} ++ ++// Enum to string map for UserTypeEnum ++const std::map user_type_enum_enum_id_to_string_map { ++ { 0, "GeneralUser" }, ++ { 3, "ProgrammingUser" }, ++ { 4, "NonAccessUser" }, ++ { 5, "DuressUser" }, ++ { 6, "DisposableUser" }, ++ { 7, "ExpiringUser" }, ++ { 9, "RemoteOnlyUser" }, ++}; ++ ++// String to enum map for UserTypeEnum ++const std::map user_type_enum_enum_string_to_id_map { ++ { "GeneralUser", 0 }, ++ { "ProgrammingUser", 3 }, ++ { "NonAccessUser", 4 }, ++ { "DuressUser", 5 }, ++ { "DisposableUser", 6 }, ++ { "ExpiringUser", 7 }, ++ { "RemoteOnlyUser", 9 }, ++}; ++ ++std::string user_type_enum_get_enum_value_name( ++ uint32_t value) ++{ ++ auto it = user_type_enum_enum_id_to_string_map.find(value); ++ if (it != user_type_enum_enum_id_to_string_map.end()){ ++ return it->second; ++ } ++ ++ // No known name value is set for this field. ++ // Set it to a string version of the value. ++ return std::to_string(value); ++} ++ ++uint32_t user_type_enum_get_enum_value_number(const std::string &str) ++{ ++ auto it = user_type_enum_enum_string_to_id_map.find(str); ++ if (it != user_type_enum_enum_string_to_id_map.end()){ ++ return it->second; ++ } ++ ++ // No known numeric value is set for this string. ++ // Return UINT32_MAX to indicate an error. ++ return std::numeric_limits::max(); ++} ++ + // Enum to string map for WindowCoveringWindowCoveringType + const std::map window_covering_window_covering_type_enum_id_to_string_map { + { 0, "Rollershade" }, +@@ -10193,6 +10416,57 @@ std::string get_enum_value_name( + #endif + } + ++ if (64776 == cluster_id) { ++ #ifdef USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ENUM_NAME_AVAILABLE ++ if (0 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_user_unique_identifiers instead of this: user_credential_supported_user_unique_identifiers ++ return user_credential_supported_user_unique_identifiers_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ENUM_NAME_AVAILABLE ++ if (1 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_credential_rules instead of this: user_credential_supported_credential_rules ++ return user_credential_supported_credential_rules_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ENUM_NAME_AVAILABLE ++ if (2 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_credential_types instead of this: user_credential_supported_credential_types ++ return user_credential_supported_credential_types_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_USER_TYPES_ENUM_NAME_AVAILABLE ++ if (3 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_user_types instead of this: user_credential_supported_user_types ++ return user_credential_supported_user_types_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ENUM_NAME_AVAILABLE ++ if (4 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_credential_checksum instead of this: user_credential_support_credential_checksum ++ return user_credential_support_credential_checksum_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ENUM_NAME_AVAILABLE ++ if (5 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_admin_pin_code instead of this: user_credential_support_admin_pin_code ++ return user_credential_support_admin_pin_code_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ENUM_NAME_AVAILABLE ++ if (6 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_admin_pin_code_deactivation instead of this: user_credential_support_admin_pin_code_deactivation ++ return user_credential_support_admin_pin_code_deactivation_get_enum_value_name(value); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_ADMIN_PIN_CODE_ENUM_NAME_AVAILABLE ++ if (7 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialadmin_pin_code instead of this: user_credential_admin_pin_code ++ return user_credential_admin_pin_code_get_enum_value_name(value); ++ } ++ #endif ++ } ++ + if (64786 == cluster_id) { + #ifdef PROTOCOL_CONTROLLER_NETWORK_MANAGEMENT_NETWORK_MANAGEMENT_STATE_ENUM_NAME_AVAILABLE + if (1 == attribute_id) { +@@ -14700,6 +14974,57 @@ uint32_t get_enum_name_value( + #endif + } + ++ if (64776 == cluster_id) { ++ #ifdef USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ENUM_NAME_AVAILABLE ++ if (0 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_user_unique_identifiers instead of this: user_credential_supported_user_unique_identifiers ++ return user_credential_supported_user_unique_identifiers_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ENUM_NAME_AVAILABLE ++ if (1 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_credential_rules instead of this: user_credential_supported_credential_rules ++ return user_credential_supported_credential_rules_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ENUM_NAME_AVAILABLE ++ if (2 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_credential_types instead of this: user_credential_supported_credential_types ++ return user_credential_supported_credential_types_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORTED_USER_TYPES_ENUM_NAME_AVAILABLE ++ if (3 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupported_user_types instead of this: user_credential_supported_user_types ++ return user_credential_supported_user_types_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ENUM_NAME_AVAILABLE ++ if (4 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_credential_checksum instead of this: user_credential_support_credential_checksum ++ return user_credential_support_credential_checksum_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ENUM_NAME_AVAILABLE ++ if (5 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_admin_pin_code instead of this: user_credential_support_admin_pin_code ++ return user_credential_support_admin_pin_code_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ENUM_NAME_AVAILABLE ++ if (6 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialsupport_admin_pin_code_deactivation instead of this: user_credential_support_admin_pin_code_deactivation ++ return user_credential_support_admin_pin_code_deactivation_get_enum_value_number(name); ++ } ++ #endif ++ #ifdef USER_CREDENTIAL_ADMIN_PIN_CODE_ENUM_NAME_AVAILABLE ++ if (7 == attribute_id) { ++ // FIXME: Some attributes don't work because multi-upper case names end up like this: user_credentialadmin_pin_code instead of this: user_credential_admin_pin_code ++ return user_credential_admin_pin_code_get_enum_value_number(name); ++ } ++ #endif ++ } ++ + if (64786 == cluster_id) { + #ifdef PROTOCOL_CONTROLLER_NETWORK_MANAGEMENT_NETWORK_MANAGEMENT_STATE_ENUM_NAME_AVAILABLE + if (1 == attribute_id) { +@@ -15182,6 +15507,28 @@ uint32_t commissioning_startup_control_get_enum_value_number_c(const char *str) + { + return commissioning_startup_control_get_enum_value_number(std::string(str)); + } ++char *cred_rule_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size) ++{ ++ snprintf(result, max_result_size, "%s", cred_rule_get_enum_value_name(value).c_str()); ++ return result; ++} ++ ++uint32_t cred_rule_get_enum_value_number_c(const char *str) ++{ ++ return cred_rule_get_enum_value_number(std::string(str)); ++} ++char *cred_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size) ++{ ++ snprintf(result, max_result_size, "%s", cred_type_get_enum_value_name(value).c_str()); ++ return result; ++} ++ ++uint32_t cred_type_get_enum_value_number_c(const char *str) ++{ ++ return cred_type_get_enum_value_number(std::string(str)); ++} + char *credential_rule_enum_get_enum_value_name_c( + uint32_t value, char *result, size_t max_result_size) + { +@@ -16194,6 +16541,39 @@ uint32_t unify_thermostat_thermostat_mode_get_enum_value_number_c(const char *st + { + return unify_thermostat_thermostat_mode_get_enum_value_number(std::string(str)); + } ++char *user_modifier_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size) ++{ ++ snprintf(result, max_result_size, "%s", user_modifier_type_get_enum_value_name(value).c_str()); ++ return result; ++} ++ ++uint32_t user_modifier_type_get_enum_value_number_c(const char *str) ++{ ++ return user_modifier_type_get_enum_value_number(std::string(str)); ++} ++char *user_name_encoding_type_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size) ++{ ++ snprintf(result, max_result_size, "%s", user_name_encoding_type_get_enum_value_name(value).c_str()); ++ return result; ++} ++ ++uint32_t user_name_encoding_type_get_enum_value_number_c(const char *str) ++{ ++ return user_name_encoding_type_get_enum_value_number(std::string(str)); ++} ++char *user_type_enum_get_enum_value_name_c( ++ uint32_t value, char *result, size_t max_result_size) ++{ ++ snprintf(result, max_result_size, "%s", user_type_enum_get_enum_value_name(value).c_str()); ++ return result; ++} ++ ++uint32_t user_type_enum_get_enum_value_number_c(const char *str) ++{ ++ return user_type_enum_get_enum_value_number(std::string(str)); ++} + char *window_covering_window_covering_type_get_enum_value_name_c( + uint32_t value, char *result, size_t max_result_size) + { +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_send_commands.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_send_commands.cpp +index 42fbbf8671..cbee8704d9 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_send_commands.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_send_commands.cpp +@@ -13506,6 +13506,1446 @@ void uic_mqtt_dotdot_configuration_parameters_publish_discover_parameter_range_c + false); + } + ++/** ++ * @brief Sends/Publishes a AddUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/AddUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/AddUser"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_user_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a AddUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/AddUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_user_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/AddUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_user_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a ModifyUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/ModifyUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/ModifyUser"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_user_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a ModifyUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/ModifyUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_user_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/ModifyUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_user_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteUser"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_user_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_user_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_user_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a AddCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/AddCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/AddCredential"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_credential_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a AddCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/AddCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_add_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_add_credential_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/AddCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_add_credential_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a ModifyCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/ModifyCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/ModifyCredential"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_credential_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a ModifyCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/ModifyCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_modify_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/ModifyCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_modify_credential_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteCredential command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteCredential ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_credential_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteCredential"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_credential_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteCredential command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteCredential ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_credential_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteCredential"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_credential_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllUsers command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllUsers ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_users_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteAllUsers"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_users_command( ++ ); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllUsers command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllUsers ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_users_command_to_group( ++ uint16_t destination_group_id ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteAllUsers"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_users_command( ++ ); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentials command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentials ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteAllCredentials"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_command( ++ ); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentials command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentials ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_command_to_group( ++ uint16_t destination_group_id ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteAllCredentials"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_command( ++ ); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsByType command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsByType ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_by_type_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteAllCredentialsByType"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsByType command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsByType ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_by_type_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_by_type_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteAllCredentialsByType"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_by_type_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUser command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsForUser ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteAllCredentialsForUser"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUser command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsForUser ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteAllCredentialsForUser"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeleteAllCredentialsForUserByType ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_by_type_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeleteAllCredentialsForUserByType"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeleteAllCredentialsForUserByType command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeleteAllCredentialsForUserByType ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_delete_all_credentials_for_user_by_type_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeleteAllCredentialsForUserByType"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_delete_all_credentials_for_user_by_type_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartAdd command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStartAdd ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_add_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/CredentialLearnStartAdd"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_add_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartAdd command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStartAdd ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_add_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/CredentialLearnStartAdd"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_add_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartModify command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStartModify ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_modify_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/CredentialLearnStartModify"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_modify_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStartModify command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStartModify ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_start_modify_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/CredentialLearnStartModify"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_start_modify_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStop command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialLearnStop ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_stop_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/CredentialLearnStop"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_stop_command( ++ ); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialLearnStop command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialLearnStop ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_learn_stop_command_to_group( ++ uint16_t destination_group_id ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/CredentialLearnStop"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_learn_stop_command( ++ ); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialAssociation command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/CredentialAssociation ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_association_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/CredentialAssociation"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_association_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a CredentialAssociation command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/CredentialAssociation ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_credential_association_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_credential_association_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/CredentialAssociation"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_credential_association_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetUserChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetUserChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_user_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/GetUserChecksum"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_user_checksum_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetUserChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetUserChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_user_checksum_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/GetUserChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_user_checksum_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetCredentialChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetCredentialChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_credential_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/GetCredentialChecksum"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_credential_checksum_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetCredentialChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetCredentialChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_credential_checksum_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_get_credential_checksum_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/GetCredentialChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_credential_checksum_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetAllUsersChecksum command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/GetAllUsersChecksum ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_all_users_checksum_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/GetAllUsersChecksum"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_all_users_checksum_command( ++ ); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a GetAllUsersChecksum command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/GetAllUsersChecksum ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_get_all_users_checksum_command_to_group( ++ uint16_t destination_group_id ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/GetAllUsersChecksum"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_get_all_users_checksum_command( ++ ); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a SetAdminPINCode command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/SetAdminPINCode ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_set_admin_pin_code_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/SetAdminPINCode"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_set_admin_pin_code_command( ++ fields); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a SetAdminPINCode command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/SetAdminPINCode ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ * @param fields Struct pointer with the fields value of the command ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_set_admin_pin_code_command_to_group( ++ uint16_t destination_group_id, ++ const uic_mqtt_dotdot_user_credential_command_set_admin_pin_code_fields_t *fields ++ ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/SetAdminPINCode"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_set_admin_pin_code_command( ++ fields); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeactivateAdminPINCode command for ++ * the UserCredential cluster to a destination. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/Commands/DeactivateAdminPINCode ++ * ++ * @param destination_unid The UNID of the node that should receive the command. ++ * ++ * @param destination_endpoint The Endpoint ID of the node that should receive the command. ++ * ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_deactivate_admin_pin_code_command( ++ const dotdot_unid_t destination_unid, ++ const dotdot_endpoint_id_t destination_endpoint ++) { ++ // Create the topic ++ std::string topic = "ucl/by-unid/"+ std::string(destination_unid) + "/ep" + ++ std::to_string(destination_endpoint) + "/"; ++ topic += "UserCredential/Commands/DeactivateAdminPINCode"; ++ ++ ++ std::string payload = ++ get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ); ++ ++ sl_log_debug(LOG_TAG, "Sending command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ ++/** ++ * @brief Sends/Publishes a DeactivateAdminPINCode command for ++ * the UserCredential cluster to a group. ++ * ++ * Publication will be made at the following topic ++ * ucl/by-group/GroupID/UserCredential/Commands/DeactivateAdminPINCode ++ * ++ * @param destination_group_id The GroupID that should receive the command. ++ * ++ */ ++void uic_mqtt_dotdot_user_credential_publish_deactivate_admin_pin_code_command_to_group( ++ uint16_t destination_group_id ++){ ++ // Create the topic ++ std::string topic = "ucl/by-group/"+ std::to_string(destination_group_id) + ++ "/UserCredential/Commands/DeactivateAdminPINCode"; ++ ++ std::string payload = ++ get_json_payload_for_user_credential_deactivate_admin_pin_code_command( ++ ); ++ ++ sl_log_info(LOG_TAG, "Sending group command to %s with payload %s ---", topic.c_str() , payload.c_str()); ++ ++ // Publish our command, not retained ++ uic_mqtt_publish(topic.c_str(), ++ payload.c_str(), ++ payload.size(), ++ false); ++} ++ + /** + * @brief Sends/Publishes a Write command for + * the ProtocolController-NetworkManagement cluster to a destination. +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_supported_generated_commands.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_supported_generated_commands.cpp +index 4d6e0f16c3..a615166fa3 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_supported_generated_commands.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_supported_generated_commands.cpp +@@ -2635,6 +2635,109 @@ void uic_mqtt_dotdot_configuration_parameters_publish_supported_generated_comman + } + + ++/** ++ * @brief Sends/Publishes a the SupportedGenerated commands for ++ * the UserCredential cluster for a UNID/Endpoint ++ * ++ * Publication will be made at the following topic ++ * ucl/by-unid/UNID/epID/UserCredential/SupportedGeneratedCommands ++ * ++ * @param unid The UNID of the node on behalf of which the advertisment is made ++ * ++ * @param endpoint The Endpoint ID of the node on behalf of which the advertisment is made ++ * ++ * @param command_list Struct pointer with the fields value indicating if ++ * individual commands can be generated. ++ */ ++void uic_mqtt_dotdot_user_credential_publish_supported_generated_commands( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint, ++ const uic_mqtt_dotdot_user_credential_supported_commands_t *command_list) ++{ ++ std::string topic = "ucl/by-unid/" + std::string(unid); ++ topic += "/ep"+ std::to_string(endpoint); ++ topic += "/UserCredential/SupportedGeneratedCommands"; ++ ++ // Assemble of vector of strings for the Supported Commands: ++ std::vector command_vector; ++ if (command_list->add_user == true) { ++ command_vector.emplace_back("AddUser"); ++ } ++ if (command_list->modify_user == true) { ++ command_vector.emplace_back("ModifyUser"); ++ } ++ if (command_list->delete_user == true) { ++ command_vector.emplace_back("DeleteUser"); ++ } ++ if (command_list->add_credential == true) { ++ command_vector.emplace_back("AddCredential"); ++ } ++ if (command_list->modify_credential == true) { ++ command_vector.emplace_back("ModifyCredential"); ++ } ++ if (command_list->delete_credential == true) { ++ command_vector.emplace_back("DeleteCredential"); ++ } ++ if (command_list->delete_all_users == true) { ++ command_vector.emplace_back("DeleteAllUsers"); ++ } ++ if (command_list->delete_all_credentials == true) { ++ command_vector.emplace_back("DeleteAllCredentials"); ++ } ++ if (command_list->delete_all_credentials_by_type == true) { ++ command_vector.emplace_back("DeleteAllCredentialsByType"); ++ } ++ if (command_list->delete_all_credentials_for_user == true) { ++ command_vector.emplace_back("DeleteAllCredentialsForUser"); ++ } ++ if (command_list->delete_all_credentials_for_user_by_type == true) { ++ command_vector.emplace_back("DeleteAllCredentialsForUserByType"); ++ } ++ if (command_list->credential_learn_start_add == true) { ++ command_vector.emplace_back("CredentialLearnStartAdd"); ++ } ++ if (command_list->credential_learn_start_modify == true) { ++ command_vector.emplace_back("CredentialLearnStartModify"); ++ } ++ if (command_list->credential_learn_stop == true) { ++ command_vector.emplace_back("CredentialLearnStop"); ++ } ++ if (command_list->credential_association == true) { ++ command_vector.emplace_back("CredentialAssociation"); ++ } ++ if (command_list->get_user_checksum == true) { ++ command_vector.emplace_back("GetUserChecksum"); ++ } ++ if (command_list->get_credential_checksum == true) { ++ command_vector.emplace_back("GetCredentialChecksum"); ++ } ++ if (command_list->get_all_users_checksum == true) { ++ command_vector.emplace_back("GetAllUsersChecksum"); ++ } ++ if (command_list->set_admin_pin_code == true) { ++ command_vector.emplace_back("SetAdminPINCode"); ++ } ++ if (command_list->deactivate_admin_pin_code == true) { ++ command_vector.emplace_back("DeactivateAdminPINCode"); ++ } ++ if (command_list->write_attributes == true) { ++ command_vector.emplace_back("WriteAttributes"); ++ } ++ ++ // JSONify, then Stringify ++ nlohmann::json json_payload; ++ json_payload["value"] = command_vector; ++ std::string string_payload = json_payload.dump(); ++ ++ // Publish to MQTT ++ uic_mqtt_publish(topic.c_str(), ++ string_payload.c_str(), ++ string_payload.length(), ++ true); ++ ++} ++ ++ + /** + * @brief Sends/Publishes a the SupportedGenerated commands for + * the ProtocolController-NetworkManagement cluster for a UNID/Endpoint +diff --git a/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include b/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include +index f3ec21da18..85fbbbd53f 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include ++++ b/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include +@@ -29,7 +29,7 @@ static sl_status_t uic_mqtt_dotdot_identify_identify_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t identify_time ++ int16_t identify_time + + ) { + uic_mqtt_dotdot_identify_identify_callback_count++; +@@ -42,7 +42,7 @@ static sl_status_t uic_mqtt_dotdot_identify_identify_query_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t timeout ++ int16_t timeout + + ) { + uic_mqtt_dotdot_identify_identify_query_response_callback_count++; +@@ -81,7 +81,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -98,7 +98,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- uint16_t group_id ++ int16_t group_id + + ) { + uic_mqtt_dotdot_groups_add_group_response_callback_count++; +@@ -111,7 +111,7 @@ static sl_status_t uic_mqtt_dotdot_groups_view_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t group_id ++ int16_t group_id + + ) { + uic_mqtt_dotdot_groups_view_group_callback_count++; +@@ -126,7 +126,7 @@ static sl_status_t uic_mqtt_dotdot_groups_view_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -142,7 +142,7 @@ static sl_status_t uic_mqtt_dotdot_groups_get_group_membership_callback_func( + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t group_list_count, +- const uint16_t *group_list ++ const int16_t *group_list + + ) { + uic_mqtt_dotdot_groups_get_group_membership_callback_count++; +@@ -155,10 +155,10 @@ static sl_status_t uic_mqtt_dotdot_groups_get_group_membership_response_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t capacity, ++ int8_t capacity, + + uint8_t group_list_count, +- const uint16_t *group_list ++ const int16_t *group_list + + ) { + uic_mqtt_dotdot_groups_get_group_membership_response_callback_count++; +@@ -171,7 +171,7 @@ static sl_status_t uic_mqtt_dotdot_groups_remove_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t group_id ++ int16_t group_id + + ) { + uic_mqtt_dotdot_groups_remove_group_callback_count++; +@@ -186,7 +186,7 @@ static sl_status_t uic_mqtt_dotdot_groups_remove_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- uint16_t group_id ++ int16_t group_id + + ) { + uic_mqtt_dotdot_groups_remove_group_response_callback_count++; +@@ -210,7 +210,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_if_identifying_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t group_id, ++ int16_t group_id, + + const char* group_name + +@@ -225,18 +225,18 @@ static sl_status_t uic_mqtt_dotdot_scenes_add_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets, + +- uint8_t transition_time100ms ++ int8_t transition_time100ms + + ) { + uic_mqtt_dotdot_scenes_add_scene_callback_count++; +@@ -251,9 +251,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_add_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_add_scene_response_callback_count++; +@@ -266,9 +266,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_view_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_view_scene_callback_count++; +@@ -283,13 +283,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_view_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -305,9 +305,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_remove_scene_callback_count++; +@@ -322,9 +322,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_remove_scene_response_callback_count++; +@@ -337,7 +337,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_all_scenes_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid ++ uint8_t * groupid + + ) { + uic_mqtt_dotdot_scenes_remove_all_scenes_callback_count++; +@@ -352,7 +352,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_fu + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid ++ uint8_t * groupid + + ) { + uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_count++; +@@ -365,9 +365,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_store_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_store_scene_callback_count++; +@@ -382,9 +382,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_store_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_store_scene_response_callback_count++; +@@ -397,11 +397,11 @@ static sl_status_t uic_mqtt_dotdot_scenes_recall_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time ++ int16_t transition_time + + ) { + uic_mqtt_dotdot_scenes_recall_scene_callback_count++; +@@ -414,7 +414,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_get_scene_membership_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid ++ uint8_t * groupid + + ) { + uic_mqtt_dotdot_scenes_get_scene_membership_callback_count++; +@@ -429,12 +429,12 @@ static sl_status_t uic_mqtt_dotdot_scenes_get_scene_membership_response_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t capacity, ++ int8_t capacity, + +- uint16_t groupid, ++ uint8_t * groupid, + + uint8_t scene_list_count, +- const uint8_t *scene_list ++ const int8_t *scene_list + + ) { + uic_mqtt_dotdot_scenes_get_scene_membership_response_callback_count++; +@@ -447,13 +447,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_add_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -471,9 +471,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback_f + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback_count++; +@@ -486,9 +486,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid ++ int8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_count++; +@@ -503,13 +503,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback_ + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t groupid, ++ uint8_t * groupid, + +- uint8_t sceneid, ++ int8_t sceneid, + +- uint16_t transition_time, ++ int16_t transition_time, + +- const char* scene_name, ++ uint8_t * scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -527,13 +527,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_copy_scene_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t mode, + +- uint16_t group_identifier_from, ++ uint8_t * group_identifier_from, + +- uint8_t scene_identifier_from, ++ int8_t scene_identifier_from, + +- uint16_t group_identifier_to, ++ uint8_t * group_identifier_to, + +- uint8_t scene_identifier_to ++ int8_t scene_identifier_to + + ) { + uic_mqtt_dotdot_scenes_copy_scene_callback_count++; +@@ -548,9 +548,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_copy_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint16_t group_identifier_from, ++ uint8_t * group_identifier_from, + +- uint8_t scene_identifier_from ++ int8_t scene_identifier_from + + ) { + uic_mqtt_dotdot_scenes_copy_scene_response_callback_count++; +@@ -598,7 +598,7 @@ static sl_status_t uic_mqtt_dotdot_on_off_off_with_effect_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + OffWithEffectEffectIdentifier effect_identifier, + +- uint8_t effect_variant ++ int8_t effect_variant + + ) { + uic_mqtt_dotdot_on_off_off_with_effect_callback_count++; +@@ -624,9 +624,9 @@ static sl_status_t uic_mqtt_dotdot_on_off_on_with_timed_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t on_off_control, + +- uint16_t on_time, ++ int16_t on_time, + +- uint16_t off_wait_time ++ int16_t off_wait_time + + ) { + uic_mqtt_dotdot_on_off_on_with_timed_off_callback_count++; +@@ -639,9 +639,9 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_level_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t level, ++ int8_t level, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -660,7 +660,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -679,9 +679,9 @@ static sl_status_t uic_mqtt_dotdot_level_step_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -713,9 +713,9 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_level_with_on_off_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t level, ++ int8_t level, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -734,7 +734,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_with_on_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -753,9 +753,9 @@ static sl_status_t uic_mqtt_dotdot_level_step_with_on_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -787,7 +787,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_closest_frequency_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t frequency ++ int16_t frequency + + ) { + uic_mqtt_dotdot_level_move_to_closest_frequency_callback_count++; +@@ -802,7 +802,7 @@ static sl_status_t uic_mqtt_dotdot_alarms_reset_alarm_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t alarm_code, + +- uint16_t cluster_identifier ++ uint8_t cluster_identifier + + ) { + uic_mqtt_dotdot_alarms_reset_alarm_callback_count++; +@@ -817,7 +817,7 @@ static sl_status_t uic_mqtt_dotdot_alarms_alarm_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t alarm_code, + +- uint16_t cluster_identifier ++ uint8_t cluster_identifier + + ) { + uic_mqtt_dotdot_alarms_alarm_callback_count++; +@@ -845,9 +845,9 @@ static sl_status_t uic_mqtt_dotdot_alarms_get_alarm_response_callback_func( + + uint8_t alarm_code, + +- uint16_t cluster_identifier, ++ uint8_t cluster_identifier, + +- uint32_t time_stamp ++ int32_t time_stamp + + ) { + uic_mqtt_dotdot_alarms_get_alarm_response_callback_count++; +@@ -895,7 +895,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_check_in_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + bool start_fast_polling, + +- uint16_t fast_poll_timeout ++ int16_t fast_poll_timeout + + ) { + uic_mqtt_dotdot_poll_control_check_in_response_callback_count++; +@@ -919,7 +919,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint32_t new_long_poll_interval ++ int32_t new_long_poll_interval + + ) { + uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback_count++; +@@ -932,7 +932,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t new_short_poll_interval ++ int16_t new_short_poll_interval + + ) { + uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback_count++; +@@ -945,7 +945,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_lock_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_lock_door_callback_count++; +@@ -971,7 +971,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unlock_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_unlock_door_callback_count++; +@@ -997,7 +997,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_toggle_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_toggle_callback_count++; +@@ -1023,9 +1023,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t timeout_in_seconds, ++ int16_t timeout_in_seconds, + +- const char* pin_or_rfid_code ++ uint8_t pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_count++; +@@ -1051,7 +1051,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_log_record_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t log_index ++ int16_t log_index + + ) { + uic_mqtt_dotdot_door_lock_get_log_record_callback_count++; +@@ -1064,19 +1064,19 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_log_record_response_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t log_entryid, ++ int16_t log_entryid, + +- uint32_t timestamp, ++ int32_t timestamp, + + GetLogRecordResponseEventType event_type, + + DrlkOperEventSource source_operation_event, + +- uint8_t event_id_or_alarm_code, ++ int8_t event_id_or_alarm_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin ++ uint8_t pin + + ) { + uic_mqtt_dotdot_door_lock_get_log_record_response_callback_count++; +@@ -1089,13 +1089,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- const char* pin ++ uint8_t pin + + ) { + uic_mqtt_dotdot_door_lock_set_pin_code_callback_count++; +@@ -1121,7 +1121,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_pin_code_callback_count++; +@@ -1134,13 +1134,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- const char* code ++ uint8_t code + + ) { + uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_count++; +@@ -1153,7 +1153,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_clear_pin_code_callback_count++; +@@ -1203,7 +1203,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_status_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status + +@@ -1231,7 +1231,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_status_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_user_status_callback_count++; +@@ -1244,7 +1244,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_status_response_callback_f + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status + +@@ -1259,19 +1259,19 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid, ++ uint8_t * userid, + + uint8_t days_mask, + +- uint8_t start_hour, ++ int8_t start_hour, + +- uint8_t start_minute, ++ int8_t start_minute, + +- uint8_t end_hour, ++ int8_t end_hour, + +- uint8_t end_minute ++ int8_t end_minute + + ) { + uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_count++; +@@ -1297,9 +1297,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_count++; +@@ -1312,21 +1312,21 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ int8_t scheduleid, + +- uint16_t userid, ++ int16_t userid, + + zclStatus status, + + uint8_t days_mask, + +- uint8_t start_hour, ++ int8_t start_hour, + +- uint8_t start_minute, ++ int8_t start_minute, + +- uint8_t end_hour, ++ int8_t end_hour, + +- uint8_t end_minute ++ int8_t end_minute + + ) { + uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback_count++; +@@ -1339,9 +1339,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_count++; +@@ -1367,13 +1367,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid, ++ uint8_t * userid, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time ++ int32_t local_end_time + + ) { + uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_count++; +@@ -1399,9 +1399,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_count++; +@@ -1414,15 +1414,15 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ int8_t scheduleid, + +- uint16_t userid, ++ int16_t userid, + + zclStatus status, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time ++ int32_t local_end_time + + ) { + uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback_count++; +@@ -1435,9 +1435,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t scheduleid, ++ uint8_t * scheduleid, + +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_count++; +@@ -1463,11 +1463,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t holiday_scheduleid, ++ uint8_t * holiday_scheduleid, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time, ++ int32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -1495,7 +1495,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t holiday_scheduleid ++ uint8_t * holiday_scheduleid + + ) { + uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_count++; +@@ -1508,13 +1508,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t holiday_scheduleid, ++ int8_t holiday_scheduleid, + + zclStatus status, + +- uint32_t local_start_time, ++ int32_t local_start_time, + +- uint32_t local_end_time, ++ int32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -1529,7 +1529,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t holiday_scheduleid ++ uint8_t * holiday_scheduleid + + ) { + uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_count++; +@@ -1555,7 +1555,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_type_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkUserType user_type + +@@ -1583,7 +1583,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_type_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_user_type_callback_count++; +@@ -1596,7 +1596,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_type_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserType user_type + +@@ -1611,13 +1611,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ uint8_t * userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- const char* rfid_code ++ uint8_t rfid_code + + ) { + uic_mqtt_dotdot_door_lock_set_rfid_code_callback_count++; +@@ -1643,7 +1643,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_get_rfid_code_callback_count++; +@@ -1656,13 +1656,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid, ++ int16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- const char* rfid_code ++ uint8_t rfid_code + + ) { + uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_count++; +@@ -1675,7 +1675,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t userid ++ uint8_t * userid + + ) { + uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_count++; +@@ -1727,11 +1727,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + DataOperationTypeEnum operation_type, + +- uint16_t user_index, ++ int16_t user_index, + + const char* user_name, + +- uint32_t user_uniqueid, ++ int32_t user_uniqueid, + + DrlkSettableUserStatus user_status, + +@@ -1750,7 +1750,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t user_index ++ int16_t user_index + + ) { + uic_mqtt_dotdot_door_lock_get_user_callback_count++; +@@ -1774,7 +1774,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t user_index ++ int16_t user_index + + ) { + uic_mqtt_dotdot_door_lock_clear_user_callback_count++; +@@ -1791,11 +1791,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_operating_event_notification_callba + + OperatingEventNotificationOperationEventCode operation_event_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin, ++ uint8_t pin, + +- uint32_t local_time, ++ int32_t local_time, + + const char* data + +@@ -1814,15 +1814,15 @@ static sl_status_t uic_mqtt_dotdot_door_lock_programming_event_notification_call + + ProgrammingEventNotificationProgramEventCode program_event_code, + +- uint16_t userid, ++ int16_t userid, + +- const char* pin, ++ uint8_t pin, + + DrlkUserType user_type, + + DrlkUserStatus user_status, + +- uint32_t local_time, ++ int32_t local_time, + + const char* data + +@@ -1841,9 +1841,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_credential_callback_func( + + CredentialStruct credential, + +- const char* credential_data, ++ uint8_t credential_data, + +- uint16_t user_index, ++ int16_t user_index, + + DrlkSettableUserStatus user_status, + +@@ -1908,7 +1908,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unbolt_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- const char* pin_code ++ uint8_t pin_code + + ) { + uic_mqtt_dotdot_door_lock_unbolt_door_callback_count++; +@@ -1954,7 +1954,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t lift_value ++ int16_t lift_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_count++; +@@ -1967,7 +1967,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t percentage_lift_value ++ int8_t percentage_lift_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback_count++; +@@ -1980,7 +1980,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t tilt_value ++ int16_t tilt_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_count++; +@@ -1993,7 +1993,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t percentage_tilt_value ++ int8_t percentage_tilt_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback_count++; +@@ -2006,7 +2006,7 @@ static sl_status_t uic_mqtt_dotdot_barrier_control_go_to_percent_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t percent_open ++ int8_t percent_open + + ) { + uic_mqtt_dotdot_barrier_control_go_to_percent_callback_count++; +@@ -2085,17 +2085,17 @@ static sl_status_t uic_mqtt_dotdot_thermostat_get_relay_status_log_response_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t time_of_day, ++ int16_t time_of_day, + + uint8_t relay_status, + + int16_t local_temperature, + +- uint8_t humidity_percentage, ++ int8_t humidity_percentage, + + int16_t set_point, + +- uint16_t unread_entries ++ int16_t unread_entries + + ) { + uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback_count++; +@@ -2145,11 +2145,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_hue_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t hue, ++ int8_t hue, + + CCDirection direction, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2168,7 +2168,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_hue_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -2187,9 +2187,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_hue_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint8_t transition_time, ++ int8_t transition_time, + + uint8_t options_mask, + +@@ -2206,9 +2206,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_saturation_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2227,7 +2227,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_saturation_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- uint8_t rate, ++ int8_t rate, + + uint8_t options_mask, + +@@ -2246,9 +2246,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_saturation_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- uint8_t step_size, ++ int8_t step_size, + +- uint8_t transition_time, ++ int8_t transition_time, + + uint8_t options_mask, + +@@ -2265,11 +2265,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t hue, ++ int8_t hue, + +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2286,11 +2286,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_color_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t colorx, ++ int16_t colorx, + +- uint16_t colory, ++ int16_t colory, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2330,7 +2330,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_color_callback_func( + + int16_t stepy, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2347,9 +2347,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_color_temperature_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t color_temperature_mireds, ++ int16_t color_temperature_mireds, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2366,11 +2366,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback_f + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t enhanced_hue, ++ int16_t enhanced_hue, + + CCDirection direction, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2389,7 +2389,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_hue_callback_func + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- uint16_t rate, ++ int16_t rate, + + uint8_t options_mask, + +@@ -2408,9 +2408,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_step_hue_callback_func + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- uint16_t step_size, ++ int16_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2427,11 +2427,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_satura + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t enhanced_hue, ++ int16_t enhanced_hue, + +- uint8_t saturation, ++ int8_t saturation, + +- uint16_t transition_time, ++ int16_t transition_time, + + uint8_t options_mask, + +@@ -2454,9 +2454,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_color_loop_set_callback_func( + + CCColorLoopDirection direction, + +- uint16_t time, ++ int16_t time, + +- uint16_t start_hue, ++ int16_t start_hue, + + uint8_t options_mask, + +@@ -2490,11 +2490,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_color_temperature_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- uint16_t rate, ++ int16_t rate, + +- uint16_t color_temperature_minimum_mireds, ++ uint8_t * color_temperature_minimum_mireds, + +- uint16_t color_temperature_maximum_mireds, ++ uint8_t * color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -2513,13 +2513,13 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_color_temperature_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- uint16_t step_size, ++ int16_t step_size, + +- uint16_t transition_time, ++ int16_t transition_time, + +- uint16_t color_temperature_minimum_mireds, ++ uint8_t * color_temperature_minimum_mireds, + +- uint16_t color_temperature_maximum_mireds, ++ uint8_t * color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -2538,7 +2538,7 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + ZoneEnrollResponseEnrollResponseCode enroll_response_code, + +- uint8_t zoneid ++ int8_t zoneid + + ) { + uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_count++; +@@ -2555,9 +2555,9 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_status_change_notification_call + + uint8_t extended_status, + +- uint8_t zoneid, ++ int8_t zoneid, + +- uint16_t delay ++ int16_t delay + + ) { + uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback_count++; +@@ -2583,7 +2583,7 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + IasZoneType zone_type, + +- uint16_t manufacturer_code ++ int16_t manufacturer_code + + ) { + uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_count++; +@@ -2596,9 +2596,9 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t test_mode_duration, ++ int8_t test_mode_duration, + +- uint8_t current_zone_sensitivity_level ++ int8_t current_zone_sensitivity_level + + ) { + uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_count++; +@@ -2613,9 +2613,9 @@ static sl_status_t uic_mqtt_dotdot_iaswd_start_warning_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t siren_configuration, + +- uint16_t warning_duration, ++ int16_t warning_duration, + +- uint8_t strobe_duty_cycle, ++ int8_t strobe_duty_cycle, + + IaswdLevel strobe_level + +@@ -2643,14 +2643,14 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_profile_info_respo + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t profile_count, ++ int8_t profile_count, + + ProfileIntervalPeriod profile_interval_period, + +- uint8_t max_number_of_intervals, ++ int8_t max_number_of_intervals, + + uint8_t list_of_attributes_count, +- const uint16_t *list_of_attributes ++ const uint8_t *list_of_attributes + + ) { + uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback_count++; +@@ -2674,18 +2674,18 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint32_t start_time, ++ uint8_t start_time, + + GetMeasurementProfileResponseStatus status, + + ProfileIntervalPeriod profile_interval_period, + +- uint8_t number_of_intervals_delivered, ++ int8_t number_of_intervals_delivered, + +- uint16_t attribute_id, ++ uint8_t attribute_id, + + uint8_t intervals_count, +- const uint8_t *intervals ++ const int8_t *intervals + + ) { + uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback_count++; +@@ -2698,11 +2698,11 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t attributeid, ++ uint8_t attributeid, + +- uint32_t start_time, ++ uint8_t start_time, + +- uint8_t number_of_intervals ++ int8_t number_of_intervals + + ) { + uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback_count++; +@@ -2721,13 +2721,13 @@ static sl_status_t uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_ca + + bool transmission_successful, + +- uint16_t transmission_time_ms, ++ int16_t transmission_time_ms, + + int8_t tx_powerd_bm, + +- uint8_t tx_channel, ++ int8_t tx_channel, + +- uint8_t routing_attempts, ++ int8_t routing_attempts, + + bool route_changed, + +@@ -2743,7 +2743,7 @@ static sl_status_t uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_ca + + int8_t ackrssi, + +- uint8_t ack_channel, ++ int8_t ack_channel, + + const char* last_route_failed_link_functionalunid, + +@@ -2836,7 +2836,7 @@ static sl_status_t uic_mqtt_dotdot_binding_bind_callback_func( + + const char* destination_unid, + +- uint8_t destination_ep ++ int8_t destination_ep + + ) { + uic_mqtt_dotdot_binding_bind_callback_count++; +@@ -2853,7 +2853,7 @@ static sl_status_t uic_mqtt_dotdot_binding_unbind_callback_func( + + const char* destination_unid, + +- uint8_t destination_ep ++ int8_t destination_ep + + ) { + uic_mqtt_dotdot_binding_unbind_callback_count++; +@@ -2911,7 +2911,7 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_discover_parameter_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t parameter_id ++ int16_t parameter_id + + ) { + uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_count++; +@@ -2935,7 +2935,7 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_set_parameter_callba + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t parameter_id, ++ int16_t parameter_id, + + int64_t value + +@@ -2950,9 +2950,9 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_discover_parameter_r + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint16_t first_parameter_id, ++ int16_t first_parameter_id, + +- uint16_t last_parameter_id ++ int16_t last_parameter_id + + ) { + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_count++; +@@ -2960,6 +2960,318 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_discover_parameter_r + return SL_STATUS_OK; + } + ++static unsigned int uic_mqtt_dotdot_user_credential_add_user_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_add_user_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ UserTypeEnum user_type, ++ ++ bool user_active_state, ++ ++ CredRule credential_rule, ++ ++ const char* user_name, ++ ++ int16_t expiring_timeout_minutes, ++ ++ UserNameEncodingType user_name_encoding ++ ++) { ++ uic_mqtt_dotdot_user_credential_add_user_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_modify_user_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_modify_user_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ UserTypeEnum user_type, ++ ++ bool user_active_state, ++ ++ CredRule credential_rule, ++ ++ const char* user_name, ++ ++ int16_t expiring_timeout_minutes, ++ ++ UserNameEncodingType user_name_encoding ++ ++) { ++ uic_mqtt_dotdot_user_credential_modify_user_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_user_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_user_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid ++ ++) { ++ uic_mqtt_dotdot_user_credential_delete_user_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_add_credential_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_add_credential_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ const char* credential_data ++ ++) { ++ uic_mqtt_dotdot_user_credential_add_credential_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_modify_credential_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_modify_credential_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ const char* credential_data ++ ++) { ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_credential_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_credential_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot ++ ++) { ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_all_users_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_users_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type ++) { ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type ++) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ CredType credential_type ++ ++) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid ++ ++) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type ++ ++) { ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ int8_t credential_learn_timeout ++ ++) { ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid, ++ ++ CredType credential_type, ++ ++ int16_t credential_slot, ++ ++ int8_t credential_learn_timeout ++ ++) { ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type ++) { ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_credential_association_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_credential_association_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ CredType credential_type, ++ ++ int16_t source_user_uniqueid, ++ ++ int16_t source_credential_slot, ++ ++ int16_t destination_user_uniqueid, ++ ++ int16_t destination_credential_slot ++ ++) { ++ uic_mqtt_dotdot_user_credential_credential_association_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_get_user_checksum_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_get_user_checksum_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ int16_t user_uniqueid ++ ++) { ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ CredType credential_type ++ ++) { ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type ++) { ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type, ++ const char* pin_code ++ ++) { ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ ++static unsigned int uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_count; ++static sl_status_t uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_func( ++ dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint, ++ uic_mqtt_dotdot_callback_call_type_t callback_type ++) { ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_count++; ++ num_command_callbacks++; ++ return SL_STATUS_OK; ++} ++ + static unsigned int uic_mqtt_dotdot_protocol_controller_network_management_write_callback_count; + static sl_status_t uic_mqtt_dotdot_protocol_controller_network_management_write_callback_func( + dotdot_unid_t unid, +@@ -3015,9 +3327,9 @@ static sl_status_t uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_ + uic_mqtt_dotdot_callback_call_type_t callback_type, + SetpointType type, + +- uint8_t precision, ++ int8_t precision, + +- uint8_t scale, ++ int8_t scale, + + int32_t value + +@@ -3403,6 +3715,46 @@ static unsigned int set_all_callbacks() + num_callbacks++; + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_set(&uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_func); + num_callbacks++; ++ uic_mqtt_dotdot_user_credential_add_user_callback_set(&uic_mqtt_dotdot_user_credential_add_user_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_modify_user_callback_set(&uic_mqtt_dotdot_user_credential_modify_user_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_user_callback_set(&uic_mqtt_dotdot_user_credential_delete_user_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_add_credential_callback_set(&uic_mqtt_dotdot_user_credential_add_credential_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_set(&uic_mqtt_dotdot_user_credential_modify_credential_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_set(&uic_mqtt_dotdot_user_credential_delete_credential_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_set(&uic_mqtt_dotdot_user_credential_delete_all_users_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set(&uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set(&uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set(&uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set(&uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set(&uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_credential_association_callback_set(&uic_mqtt_dotdot_user_credential_credential_association_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set(&uic_mqtt_dotdot_user_credential_get_user_checksum_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set(&uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set(&uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set(&uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_func); ++ num_callbacks++; ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set(&uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_func); ++ num_callbacks++; + uic_mqtt_dotdot_protocol_controller_network_management_write_callback_set(&uic_mqtt_dotdot_protocol_controller_network_management_write_callback_func); + num_callbacks++; + uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_set(&uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_func); +@@ -3653,6 +4005,27 @@ static void unset_all_callbacks() + uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_clear(); + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_clear(); + uic_mqtt_dotdot_clear_configuration_parameters_write_attributes_callbacks(); ++ uic_mqtt_dotdot_user_credential_add_user_callback_clear(); ++ uic_mqtt_dotdot_user_credential_modify_user_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_user_callback_clear(); ++ uic_mqtt_dotdot_user_credential_add_credential_callback_clear(); ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_clear(); ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_clear(); ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_clear(); ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_clear(); ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_clear(); ++ uic_mqtt_dotdot_user_credential_credential_association_callback_clear(); ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_clear(); ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_clear(); ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_clear(); ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_clear(); ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_clear(); ++ uic_mqtt_dotdot_clear_user_credential_write_attributes_callbacks(); + uic_mqtt_dotdot_protocol_controller_network_management_write_callback_clear(); + uic_mqtt_dotdot_clear_protocol_controller_network_management_write_attributes_callbacks(); + uic_mqtt_dotdot_clear_descriptor_write_attributes_callbacks(); +@@ -3854,6 +4227,26 @@ static void reset_callback_counters() + uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_count = 0; + uic_mqtt_dotdot_configuration_parameters_set_parameter_callback_count = 0; + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_add_user_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_modify_user_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_user_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_add_credential_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_credential_association_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_count = 0; ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_count = 0; + uic_mqtt_dotdot_protocol_controller_network_management_write_callback_count = 0; + uic_mqtt_dotdot_unify_fan_control_set_fan_mode_callback_count = 0; + uic_mqtt_dotdot_unify_fan_control_turn_off_callback_count = 0; +diff --git a/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes.uam b/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes.uam +index 2bf45a75f1..68ed25df42 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes.uam ++++ b/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes.uam +@@ -834,6 +834,16 @@ def DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION 0xfd060001 + // This represents the attributes in the DotDot ConfigurationParameters cluster + def DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS 0xfd070000 + ++// This represents the attributes in the DotDot UserCredential cluster ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS 0xfd080000 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES 0xfd080001 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES 0xfd080002 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES 0xfd080003 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM 0xfd080004 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE 0xfd080005 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION 0xfd080006 ++def DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE 0xfd080007 ++ + // This represents the attributes in the DotDot AoXLocator cluster + def DOTDOT_ATTRIBUTE_ID_AOX_LOCATOR_REPORTING_MODE 0xfd100001 + def DOTDOT_ATTRIBUTE_ID_AOX_LOCATOR_POSITION_AND_ORIENTATION_VALID 0xfd100002 +diff --git a/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes_camel_case.uam b/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes_camel_case.uam +index ceb159d2c2..440dddc2ea 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes_camel_case.uam ++++ b/components/unify_dotdot_attribute_store/zap-generated/include/dotdot_attributes_camel_case.uam +@@ -834,6 +834,16 @@ def zb_Location 0xfd060001 + // This represents short CamelCase labels the attributes in the DotDot ConfigurationParameters cluster + def zb_ConfigurationParameters 0xfd070000 + ++// This represents short CamelCase labels the attributes in the DotDot UserCredential cluster ++def zb_SupportedUserUniqueIdentifiers 0xfd080000 ++def zb_SupportedCredentialRules 0xfd080001 ++def zb_SupportedCredentialTypes 0xfd080002 ++def zb_SupportedUserTypes 0xfd080003 ++def zb_SupportCredentialChecksum 0xfd080004 ++def zb_SupportAdminPinCode 0xfd080005 ++def zb_SupportAdminPinCodeDeactivation 0xfd080006 ++def zb_AdminPinCode 0xfd080007 ++ + // This represents short CamelCase labels the attributes in the DotDot AoXLocator cluster + def zb_ReportingMode 0xfd100001 + def zb_PositionAndOrientationValid 0xfd100002 +diff --git a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h +index f99ee31747..3693cf08fb 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h ++++ b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h +@@ -63,7 +63,7 @@ bool dotdot_is_supported_basic_zcl_version ( + * + * @returns ZCLVersion attribute + */ +-uint8_t dotdot_get_basic_zcl_version( ++int8_t dotdot_get_basic_zcl_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -83,7 +83,7 @@ sl_status_t dotdot_set_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_zcl_version ++ int8_t new_zcl_version + ); + + /** +@@ -169,7 +169,7 @@ bool dotdot_is_supported_basic_application_version ( + * + * @returns ApplicationVersion attribute + */ +-uint8_t dotdot_get_basic_application_version( ++int8_t dotdot_get_basic_application_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -189,7 +189,7 @@ sl_status_t dotdot_set_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_application_version ++ int8_t new_application_version + ); + + /** +@@ -275,7 +275,7 @@ bool dotdot_is_supported_basic_stack_version ( + * + * @returns StackVersion attribute + */ +-uint8_t dotdot_get_basic_stack_version( ++int8_t dotdot_get_basic_stack_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -295,7 +295,7 @@ sl_status_t dotdot_set_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_stack_version ++ int8_t new_stack_version + ); + + /** +@@ -381,7 +381,7 @@ bool dotdot_is_supported_basic_hw_version ( + * + * @returns HWVersion attribute + */ +-uint8_t dotdot_get_basic_hw_version( ++int8_t dotdot_get_basic_hw_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -401,7 +401,7 @@ sl_status_t dotdot_set_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_hw_version ++ int8_t new_hw_version + ); + + /** +@@ -1135,7 +1135,7 @@ bool dotdot_is_supported_basic_product_code ( + * + * @returns ProductCode attribute + */ +-const char* dotdot_get_basic_product_code( ++uint8_t dotdot_get_basic_product_code( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -1155,7 +1155,7 @@ sl_status_t dotdot_set_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_product_code ++ uint8_t new_product_code + ); + + /** +@@ -2347,7 +2347,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage ( + * + * @returns MainsVoltage attribute + */ +-uint16_t dotdot_get_power_configuration_mains_voltage( ++int16_t dotdot_get_power_configuration_mains_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2367,7 +2367,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage ++ int16_t new_mains_voltage + ); + + /** +@@ -2453,7 +2453,7 @@ bool dotdot_is_supported_power_configuration_mains_frequency ( + * + * @returns MainsFrequency attribute + */ +-uint8_t dotdot_get_power_configuration_mains_frequency( ++int8_t dotdot_get_power_configuration_mains_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2473,7 +2473,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_mains_frequency ++ int8_t new_mains_frequency + ); + + /** +@@ -2665,7 +2665,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_min_threshold ( + * + * @returns MainsVoltageMinThreshold attribute + */ +-uint16_t dotdot_get_power_configuration_mains_voltage_min_threshold( ++int16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2685,7 +2685,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_min_threshold ++ int16_t new_mains_voltage_min_threshold + ); + + /** +@@ -2771,7 +2771,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_max_threshold ( + * + * @returns MainsVoltageMaxThreshold attribute + */ +-uint16_t dotdot_get_power_configuration_mains_voltage_max_threshold( ++int16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2791,7 +2791,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_max_threshold ++ int16_t new_mains_voltage_max_threshold + ); + + /** +@@ -2877,7 +2877,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_dwell_trip_point ( + * + * @returns MainsVoltageDwellTripPoint attribute + */ +-uint16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( ++int16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2897,7 +2897,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_dwell_trip_point ++ int16_t new_mains_voltage_dwell_trip_point + ); + + /** +@@ -2983,7 +2983,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage ( + * + * @returns BatteryVoltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery_voltage( ++int8_t dotdot_get_power_configuration_battery_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3003,7 +3003,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage ++ int8_t new_battery_voltage + ); + + /** +@@ -3089,7 +3089,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_remaining ( + * + * @returns BatteryPercentageRemaining attribute + */ +-uint8_t dotdot_get_power_configuration_battery_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3109,7 +3109,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_remaining ++ int8_t new_battery_percentage_remaining + ); + + /** +@@ -3410,7 +3410,7 @@ bool dotdot_is_supported_power_configuration_batterya_hr_rating ( + * + * @returns BatteryAHrRating attribute + */ +-uint16_t dotdot_get_power_configuration_batterya_hr_rating( ++int16_t dotdot_get_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3430,7 +3430,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_batterya_hr_rating ++ int16_t new_batterya_hr_rating + ); + + /** +@@ -3516,7 +3516,7 @@ bool dotdot_is_supported_power_configuration_battery_quantity ( + * + * @returns BatteryQuantity attribute + */ +-uint8_t dotdot_get_power_configuration_battery_quantity( ++int8_t dotdot_get_power_configuration_battery_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3536,7 +3536,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_quantity ++ int8_t new_battery_quantity + ); + + /** +@@ -3622,7 +3622,7 @@ bool dotdot_is_supported_power_configuration_battery_rated_voltage ( + * + * @returns BatteryRatedVoltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery_rated_voltage( ++int8_t dotdot_get_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3642,7 +3642,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_rated_voltage ++ int8_t new_battery_rated_voltage + ); + + /** +@@ -3834,7 +3834,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_min_threshold ( + * + * @returns BatteryVoltageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3854,7 +3854,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_min_threshold ++ int8_t new_battery_voltage_min_threshold + ); + + /** +@@ -3940,7 +3940,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold1 ( + * + * @returns BatteryVoltageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3960,7 +3960,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold1 ++ int8_t new_battery_voltage_threshold1 + ); + + /** +@@ -4046,7 +4046,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold2 ( + * + * @returns BatteryVoltageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4066,7 +4066,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold2 ++ int8_t new_battery_voltage_threshold2 + ); + + /** +@@ -4152,7 +4152,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold3 ( + * + * @returns BatteryVoltageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4172,7 +4172,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold3 ++ int8_t new_battery_voltage_threshold3 + ); + + /** +@@ -4258,7 +4258,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_min_threshold ( + * + * @returns BatteryPercentageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4278,7 +4278,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_min_threshold ++ int8_t new_battery_percentage_min_threshold + ); + + /** +@@ -4364,7 +4364,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold1 ( + * + * @returns BatteryPercentageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4384,7 +4384,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold1 ++ int8_t new_battery_percentage_threshold1 + ); + + /** +@@ -4470,7 +4470,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold2 ( + * + * @returns BatteryPercentageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4490,7 +4490,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold2 ++ int8_t new_battery_percentage_threshold2 + ); + + /** +@@ -4576,7 +4576,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold3 ( + * + * @returns BatteryPercentageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4596,7 +4596,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold3 ++ int8_t new_battery_percentage_threshold3 + ); + + /** +@@ -4788,7 +4788,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage ( + * + * @returns Battery2Voltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_voltage( ++int8_t dotdot_get_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4808,7 +4808,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage ++ int8_t new_battery2_voltage + ); + + /** +@@ -4894,7 +4894,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_remaining ( + * + * @returns Battery2PercentageRemaining attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4914,7 +4914,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_remaining ++ int8_t new_battery2_percentage_remaining + ); + + /** +@@ -5215,7 +5215,7 @@ bool dotdot_is_supported_power_configuration_battery2a_hr_rating ( + * + * @returns Battery2AHrRating attribute + */ +-uint16_t dotdot_get_power_configuration_battery2a_hr_rating( ++int16_t dotdot_get_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5235,7 +5235,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_battery2a_hr_rating ++ int16_t new_battery2a_hr_rating + ); + + /** +@@ -5321,7 +5321,7 @@ bool dotdot_is_supported_power_configuration_battery2_quantity ( + * + * @returns Battery2Quantity attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_quantity( ++int8_t dotdot_get_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5341,7 +5341,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_quantity ++ int8_t new_battery2_quantity + ); + + /** +@@ -5427,7 +5427,7 @@ bool dotdot_is_supported_power_configuration_battery2_rated_voltage ( + * + * @returns Battery2RatedVoltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_rated_voltage( ++int8_t dotdot_get_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5447,7 +5447,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_rated_voltage ++ int8_t new_battery2_rated_voltage + ); + + /** +@@ -5639,7 +5639,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_min_threshold ( + * + * @returns Battery2VoltageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5659,7 +5659,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_min_threshold ++ int8_t new_battery2_voltage_min_threshold + ); + + /** +@@ -5745,7 +5745,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold1 ( + * + * @returns Battery2VoltageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5765,7 +5765,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold1 ++ int8_t new_battery2_voltage_threshold1 + ); + + /** +@@ -5851,7 +5851,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold2 ( + * + * @returns Battery2VoltageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5871,7 +5871,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold2 ++ int8_t new_battery2_voltage_threshold2 + ); + + /** +@@ -5957,7 +5957,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold3 ( + * + * @returns Battery2VoltageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5977,7 +5977,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold3 ++ int8_t new_battery2_voltage_threshold3 + ); + + /** +@@ -6063,7 +6063,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_min_threshold ( + * + * @returns Battery2PercentageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6083,7 +6083,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_min_threshold ++ int8_t new_battery2_percentage_min_threshold + ); + + /** +@@ -6169,7 +6169,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold1 ( + * + * @returns Battery2PercentageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6189,7 +6189,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold1 ++ int8_t new_battery2_percentage_threshold1 + ); + + /** +@@ -6275,7 +6275,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold2 ( + * + * @returns Battery2PercentageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6295,7 +6295,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold2 ++ int8_t new_battery2_percentage_threshold2 + ); + + /** +@@ -6381,7 +6381,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold3 ( + * + * @returns Battery2PercentageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6401,7 +6401,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold3 ++ int8_t new_battery2_percentage_threshold3 + ); + + /** +@@ -6593,7 +6593,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage ( + * + * @returns Battery3Voltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_voltage( ++int8_t dotdot_get_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6613,7 +6613,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage ++ int8_t new_battery3_voltage + ); + + /** +@@ -6699,7 +6699,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_remaining ( + * + * @returns Battery3PercentageRemaining attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6719,7 +6719,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_remaining ++ int8_t new_battery3_percentage_remaining + ); + + /** +@@ -7020,7 +7020,7 @@ bool dotdot_is_supported_power_configuration_battery3a_hr_rating ( + * + * @returns Battery3AHrRating attribute + */ +-uint16_t dotdot_get_power_configuration_battery3a_hr_rating( ++int16_t dotdot_get_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7040,7 +7040,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_battery3a_hr_rating ++ int16_t new_battery3a_hr_rating + ); + + /** +@@ -7126,7 +7126,7 @@ bool dotdot_is_supported_power_configuration_battery3_quantity ( + * + * @returns Battery3Quantity attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_quantity( ++int8_t dotdot_get_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7146,7 +7146,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_quantity ++ int8_t new_battery3_quantity + ); + + /** +@@ -7232,7 +7232,7 @@ bool dotdot_is_supported_power_configuration_battery3_rated_voltage ( + * + * @returns Battery3RatedVoltage attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_rated_voltage( ++int8_t dotdot_get_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7252,7 +7252,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_rated_voltage ++ int8_t new_battery3_rated_voltage + ); + + /** +@@ -7444,7 +7444,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_min_threshold ( + * + * @returns Battery3VoltageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7464,7 +7464,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_min_threshold ++ int8_t new_battery3_voltage_min_threshold + ); + + /** +@@ -7550,7 +7550,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold1 ( + * + * @returns Battery3VoltageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7570,7 +7570,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold1 ++ int8_t new_battery3_voltage_threshold1 + ); + + /** +@@ -7656,7 +7656,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold2 ( + * + * @returns Battery3VoltageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7676,7 +7676,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold2 ++ int8_t new_battery3_voltage_threshold2 + ); + + /** +@@ -7762,7 +7762,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold3 ( + * + * @returns Battery3VoltageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7782,7 +7782,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold3 ++ int8_t new_battery3_voltage_threshold3 + ); + + /** +@@ -7868,7 +7868,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_min_threshold ( + * + * @returns Battery3PercentageMinThreshold attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7888,7 +7888,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_min_threshold ++ int8_t new_battery3_percentage_min_threshold + ); + + /** +@@ -7974,7 +7974,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold1 ( + * + * @returns Battery3PercentageThreshold1 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7994,7 +7994,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold1 ++ int8_t new_battery3_percentage_threshold1 + ); + + /** +@@ -8080,7 +8080,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold2 ( + * + * @returns Battery3PercentageThreshold2 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8100,7 +8100,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold2 ++ int8_t new_battery3_percentage_threshold2 + ); + + /** +@@ -8186,7 +8186,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold3 ( + * + * @returns Battery3PercentageThreshold3 attribute + */ +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8206,7 +8206,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold3 ++ int8_t new_battery3_percentage_threshold3 + ); + + /** +@@ -8744,7 +8744,7 @@ bool dotdot_is_supported_device_temperature_configuration_over_temp_total_dwell + * + * @returns OverTempTotalDwell attribute + */ +-uint16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( ++int16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8764,7 +8764,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_over_temp_total_dwell ++ int16_t new_over_temp_total_dwell + ); + + /** +@@ -9168,7 +9168,7 @@ bool dotdot_is_supported_device_temperature_configuration_low_temp_dwell_trip_po + * + * @returns LowTempDwellTripPoint attribute + */ +-uint32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( ++int32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9188,7 +9188,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_low_temp_dwell_trip_point ++ int32_t new_low_temp_dwell_trip_point + ); + + /** +@@ -9274,7 +9274,7 @@ bool dotdot_is_supported_device_temperature_configuration_high_temp_dwell_trip_p + * + * @returns HighTempDwellTripPoint attribute + */ +-uint32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( ++int32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9294,7 +9294,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_high_temp_dwell_trip_point ++ int32_t new_high_temp_dwell_trip_point + ); + + /** +@@ -9408,7 +9408,7 @@ bool dotdot_is_supported_identify_identify_time ( + * + * @returns IdentifyTime attribute + */ +-uint16_t dotdot_get_identify_identify_time( ++int16_t dotdot_get_identify_identify_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9428,7 +9428,7 @@ sl_status_t dotdot_set_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_identify_time ++ int16_t new_identify_time + ); + + /** +@@ -9676,7 +9676,7 @@ bool dotdot_is_supported_scenes_scene_count ( + * + * @returns SceneCount attribute + */ +-uint8_t dotdot_get_scenes_scene_count( ++int8_t dotdot_get_scenes_scene_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9696,7 +9696,7 @@ sl_status_t dotdot_set_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_scene_count ++ int8_t new_scene_count + ); + + /** +@@ -9782,7 +9782,7 @@ bool dotdot_is_supported_scenes_current_scene ( + * + * @returns CurrentScene attribute + */ +-uint8_t dotdot_get_scenes_current_scene( ++int8_t dotdot_get_scenes_current_scene( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9802,7 +9802,7 @@ sl_status_t dotdot_set_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_scene ++ int8_t new_current_scene + ); + + /** +@@ -9888,7 +9888,7 @@ bool dotdot_is_supported_scenes_current_group ( + * + * @returns CurrentGroup attribute + */ +-uint16_t dotdot_get_scenes_current_group( ++uint8_t * dotdot_get_scenes_current_group( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9908,7 +9908,7 @@ sl_status_t dotdot_set_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_group ++ uint8_t * new_current_group + ); + + /** +@@ -10661,7 +10661,7 @@ bool dotdot_is_supported_on_off_on_time ( + * + * @returns OnTime attribute + */ +-uint16_t dotdot_get_on_off_on_time( ++int16_t dotdot_get_on_off_on_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -10681,7 +10681,7 @@ sl_status_t dotdot_set_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_time ++ int16_t new_on_time + ); + + /** +@@ -10767,7 +10767,7 @@ bool dotdot_is_supported_on_off_off_wait_time ( + * + * @returns OffWaitTime attribute + */ +-uint16_t dotdot_get_on_off_off_wait_time( ++int16_t dotdot_get_on_off_off_wait_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -10787,7 +10787,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_off_wait_time ++ int16_t new_off_wait_time + ); + + /** +@@ -11007,7 +11007,7 @@ bool dotdot_is_supported_level_current_level ( + * + * @returns CurrentLevel attribute + */ +-uint8_t dotdot_get_level_current_level( ++int8_t dotdot_get_level_current_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11027,7 +11027,7 @@ sl_status_t dotdot_set_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_level ++ int8_t new_current_level + ); + + /** +@@ -11113,7 +11113,7 @@ bool dotdot_is_supported_level_remaining_time ( + * + * @returns RemainingTime attribute + */ +-uint16_t dotdot_get_level_remaining_time( ++int16_t dotdot_get_level_remaining_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11133,7 +11133,7 @@ sl_status_t dotdot_set_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_remaining_time ++ int16_t new_remaining_time + ); + + /** +@@ -11219,7 +11219,7 @@ bool dotdot_is_supported_level_min_level ( + * + * @returns MinLevel attribute + */ +-uint8_t dotdot_get_level_min_level( ++int8_t dotdot_get_level_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11239,7 +11239,7 @@ sl_status_t dotdot_set_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_level ++ int8_t new_min_level + ); + + /** +@@ -11325,7 +11325,7 @@ bool dotdot_is_supported_level_max_level ( + * + * @returns MaxLevel attribute + */ +-uint8_t dotdot_get_level_max_level( ++int8_t dotdot_get_level_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11345,7 +11345,7 @@ sl_status_t dotdot_set_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_level ++ int8_t new_max_level + ); + + /** +@@ -11431,7 +11431,7 @@ bool dotdot_is_supported_level_current_frequency ( + * + * @returns CurrentFrequency attribute + */ +-uint16_t dotdot_get_level_current_frequency( ++int16_t dotdot_get_level_current_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11451,7 +11451,7 @@ sl_status_t dotdot_set_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_frequency ++ int16_t new_current_frequency + ); + + /** +@@ -11537,7 +11537,7 @@ bool dotdot_is_supported_level_min_frequency ( + * + * @returns MinFrequency attribute + */ +-uint16_t dotdot_get_level_min_frequency( ++int16_t dotdot_get_level_min_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11557,7 +11557,7 @@ sl_status_t dotdot_set_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_frequency ++ int16_t new_min_frequency + ); + + /** +@@ -11643,7 +11643,7 @@ bool dotdot_is_supported_level_max_frequency ( + * + * @returns MaxFrequency attribute + */ +-uint16_t dotdot_get_level_max_frequency( ++int16_t dotdot_get_level_max_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11663,7 +11663,7 @@ sl_status_t dotdot_set_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_frequency ++ int16_t new_max_frequency + ); + + /** +@@ -11855,7 +11855,7 @@ bool dotdot_is_supported_level_on_off_transition_time ( + * + * @returns OnOffTransitionTime attribute + */ +-uint16_t dotdot_get_level_on_off_transition_time( ++int16_t dotdot_get_level_on_off_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11875,7 +11875,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_off_transition_time ++ int16_t new_on_off_transition_time + ); + + /** +@@ -11961,7 +11961,7 @@ bool dotdot_is_supported_level_on_level ( + * + * @returns OnLevel attribute + */ +-uint8_t dotdot_get_level_on_level( ++int8_t dotdot_get_level_on_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11981,7 +11981,7 @@ sl_status_t dotdot_set_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_on_level ++ int8_t new_on_level + ); + + /** +@@ -12067,7 +12067,7 @@ bool dotdot_is_supported_level_on_transition_time ( + * + * @returns OnTransitionTime attribute + */ +-uint16_t dotdot_get_level_on_transition_time( ++int16_t dotdot_get_level_on_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12087,7 +12087,7 @@ sl_status_t dotdot_set_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_transition_time ++ int16_t new_on_transition_time + ); + + /** +@@ -12173,7 +12173,7 @@ bool dotdot_is_supported_level_off_transition_time ( + * + * @returns OffTransitionTime attribute + */ +-uint16_t dotdot_get_level_off_transition_time( ++int16_t dotdot_get_level_off_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12193,7 +12193,7 @@ sl_status_t dotdot_set_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_off_transition_time ++ int16_t new_off_transition_time + ); + + /** +@@ -12279,7 +12279,7 @@ bool dotdot_is_supported_level_default_move_rate ( + * + * @returns DefaultMoveRate attribute + */ +-uint16_t dotdot_get_level_default_move_rate( ++int16_t dotdot_get_level_default_move_rate( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12299,7 +12299,7 @@ sl_status_t dotdot_set_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_default_move_rate ++ int16_t new_default_move_rate + ); + + /** +@@ -12385,7 +12385,7 @@ bool dotdot_is_supported_level_start_up_current_level ( + * + * @returns StartUpCurrentLevel attribute + */ +-uint8_t dotdot_get_level_start_up_current_level( ++int8_t dotdot_get_level_start_up_current_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12405,7 +12405,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_start_up_current_level ++ int8_t new_start_up_current_level + ); + + /** +@@ -12519,7 +12519,7 @@ bool dotdot_is_supported_alarms_alarm_count ( + * + * @returns AlarmCount attribute + */ +-uint16_t dotdot_get_alarms_alarm_count( ++int16_t dotdot_get_alarms_alarm_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12539,7 +12539,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_alarm_count ++ int16_t new_alarm_count + ); + + /** +@@ -12653,7 +12653,7 @@ bool dotdot_is_supported_time_time ( + * + * @returns Time attribute + */ +-uint32_t dotdot_get_time_time( ++uint8_t dotdot_get_time_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12673,7 +12673,7 @@ sl_status_t dotdot_set_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_time ++ uint8_t new_time + ); + + /** +@@ -12971,7 +12971,7 @@ bool dotdot_is_supported_time_dst_start ( + * + * @returns DstStart attribute + */ +-uint32_t dotdot_get_time_dst_start( ++int32_t dotdot_get_time_dst_start( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12991,7 +12991,7 @@ sl_status_t dotdot_set_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_dst_start ++ int32_t new_dst_start + ); + + /** +@@ -13077,7 +13077,7 @@ bool dotdot_is_supported_time_dst_end ( + * + * @returns DstEnd attribute + */ +-uint32_t dotdot_get_time_dst_end( ++int32_t dotdot_get_time_dst_end( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13097,7 +13097,7 @@ sl_status_t dotdot_set_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_dst_end ++ int32_t new_dst_end + ); + + /** +@@ -13289,7 +13289,7 @@ bool dotdot_is_supported_time_standard_time ( + * + * @returns StandardTime attribute + */ +-uint32_t dotdot_get_time_standard_time( ++int32_t dotdot_get_time_standard_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13309,7 +13309,7 @@ sl_status_t dotdot_set_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_standard_time ++ int32_t new_standard_time + ); + + /** +@@ -13395,7 +13395,7 @@ bool dotdot_is_supported_time_local_time ( + * + * @returns LocalTime attribute + */ +-uint32_t dotdot_get_time_local_time( ++int32_t dotdot_get_time_local_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13415,7 +13415,7 @@ sl_status_t dotdot_set_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_local_time ++ int32_t new_local_time + ); + + /** +@@ -13501,7 +13501,7 @@ bool dotdot_is_supported_time_last_set_time ( + * + * @returns LastSetTime attribute + */ +-uint32_t dotdot_get_time_last_set_time( ++uint8_t dotdot_get_time_last_set_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13521,7 +13521,7 @@ sl_status_t dotdot_set_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_last_set_time ++ uint8_t new_last_set_time + ); + + /** +@@ -13607,7 +13607,7 @@ bool dotdot_is_supported_time_valid_until_time ( + * + * @returns ValidUntilTime attribute + */ +-uint32_t dotdot_get_time_valid_until_time( ++uint8_t dotdot_get_time_valid_until_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13627,7 +13627,7 @@ sl_status_t dotdot_set_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_valid_until_time ++ uint8_t new_valid_until_time + ); + + /** +@@ -13741,7 +13741,7 @@ bool dotdot_is_supported_poll_control_check_in_interval ( + * + * @returns CheckInInterval attribute + */ +-uint32_t dotdot_get_poll_control_check_in_interval( ++int32_t dotdot_get_poll_control_check_in_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13761,7 +13761,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_check_in_interval ++ int32_t new_check_in_interval + ); + + /** +@@ -13847,7 +13847,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval ( + * + * @returns LongPollInterval attribute + */ +-uint32_t dotdot_get_poll_control_long_poll_interval( ++int32_t dotdot_get_poll_control_long_poll_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13867,7 +13867,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_long_poll_interval ++ int32_t new_long_poll_interval + ); + + /** +@@ -13953,7 +13953,7 @@ bool dotdot_is_supported_poll_control_short_poll_interval ( + * + * @returns ShortPollInterval attribute + */ +-uint16_t dotdot_get_poll_control_short_poll_interval( ++int16_t dotdot_get_poll_control_short_poll_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13973,7 +13973,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_short_poll_interval ++ int16_t new_short_poll_interval + ); + + /** +@@ -14059,7 +14059,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout ( + * + * @returns FastPollTimeout attribute + */ +-uint16_t dotdot_get_poll_control_fast_poll_timeout( ++int16_t dotdot_get_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14079,7 +14079,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_fast_poll_timeout ++ int16_t new_fast_poll_timeout + ); + + /** +@@ -14165,7 +14165,7 @@ bool dotdot_is_supported_poll_control_check_in_interval_min ( + * + * @returns CheckInIntervalMin attribute + */ +-uint32_t dotdot_get_poll_control_check_in_interval_min( ++int32_t dotdot_get_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14185,7 +14185,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_check_in_interval_min ++ int32_t new_check_in_interval_min + ); + + /** +@@ -14271,7 +14271,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval_min ( + * + * @returns LongPollIntervalMin attribute + */ +-uint32_t dotdot_get_poll_control_long_poll_interval_min( ++int32_t dotdot_get_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14291,7 +14291,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_long_poll_interval_min ++ int32_t new_long_poll_interval_min + ); + + /** +@@ -14377,7 +14377,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout_max ( + * + * @returns FastPollTimeoutMax attribute + */ +-uint16_t dotdot_get_poll_control_fast_poll_timeout_max( ++int16_t dotdot_get_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14397,7 +14397,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_fast_poll_timeout_max ++ int16_t new_fast_poll_timeout_max + ); + + /** +@@ -14511,7 +14511,7 @@ bool dotdot_is_supported_shade_configuration_physical_closed_limit ( + * + * @returns PhysicalClosedLimit attribute + */ +-uint16_t dotdot_get_shade_configuration_physical_closed_limit( ++int16_t dotdot_get_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14531,7 +14531,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit ++ int16_t new_physical_closed_limit + ); + + /** +@@ -14617,7 +14617,7 @@ bool dotdot_is_supported_shade_configuration_motor_step_size ( + * + * @returns MotorStepSize attribute + */ +-uint8_t dotdot_get_shade_configuration_motor_step_size( ++int8_t dotdot_get_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14637,7 +14637,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_motor_step_size ++ int8_t new_motor_step_size + ); + + /** +@@ -14829,7 +14829,7 @@ bool dotdot_is_supported_shade_configuration_closed_limit ( + * + * @returns ClosedLimit attribute + */ +-uint16_t dotdot_get_shade_configuration_closed_limit( ++int16_t dotdot_get_shade_configuration_closed_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14849,7 +14849,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_closed_limit ++ int16_t new_closed_limit + ); + + /** +@@ -15493,7 +15493,7 @@ bool dotdot_is_supported_door_lock_door_open_events ( + * + * @returns DoorOpenEvents attribute + */ +-uint32_t dotdot_get_door_lock_door_open_events( ++int32_t dotdot_get_door_lock_door_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15513,7 +15513,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_door_open_events ++ int32_t new_door_open_events + ); + + /** +@@ -15599,7 +15599,7 @@ bool dotdot_is_supported_door_lock_door_closed_events ( + * + * @returns DoorClosedEvents attribute + */ +-uint32_t dotdot_get_door_lock_door_closed_events( ++int32_t dotdot_get_door_lock_door_closed_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15619,7 +15619,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_door_closed_events ++ int32_t new_door_closed_events + ); + + /** +@@ -15705,7 +15705,7 @@ bool dotdot_is_supported_door_lock_open_period ( + * + * @returns OpenPeriod attribute + */ +-uint16_t dotdot_get_door_lock_open_period( ++int16_t dotdot_get_door_lock_open_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15725,7 +15725,7 @@ sl_status_t dotdot_set_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_period ++ int16_t new_open_period + ); + + /** +@@ -15811,7 +15811,7 @@ bool dotdot_is_supported_door_lock_number_of_log_records_supported ( + * + * @returns NumberOfLogRecordsSupported attribute + */ +-uint16_t dotdot_get_door_lock_number_of_log_records_supported( ++int16_t dotdot_get_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15831,7 +15831,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_log_records_supported ++ int16_t new_number_of_log_records_supported + ); + + /** +@@ -15917,7 +15917,7 @@ bool dotdot_is_supported_door_lock_number_of_total_users_supported ( + * + * @returns NumberOfTotalUsersSupported attribute + */ +-uint16_t dotdot_get_door_lock_number_of_total_users_supported( ++int16_t dotdot_get_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15937,7 +15937,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_total_users_supported ++ int16_t new_number_of_total_users_supported + ); + + /** +@@ -16023,7 +16023,7 @@ bool dotdot_is_supported_door_lock_number_of_pin_users_supported ( + * + * @returns NumberOfPINUsersSupported attribute + */ +-uint16_t dotdot_get_door_lock_number_of_pin_users_supported( ++int16_t dotdot_get_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16043,7 +16043,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_pin_users_supported ++ int16_t new_number_of_pin_users_supported + ); + + /** +@@ -16129,7 +16129,7 @@ bool dotdot_is_supported_door_lock_number_of_rfid_users_supported ( + * + * @returns NumberOfRFIDUsersSupported attribute + */ +-uint16_t dotdot_get_door_lock_number_of_rfid_users_supported( ++int16_t dotdot_get_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16149,7 +16149,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_rfid_users_supported ++ int16_t new_number_of_rfid_users_supported + ); + + /** +@@ -16235,7 +16235,7 @@ bool dotdot_is_supported_door_lock_number_of_week_day_schedules_supported_per_us + * + * @returns NumberOfWeekDaySchedulesSupportedPerUser attribute + */ +-uint8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16255,7 +16255,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_week_day_schedules_supported_per_user ++ int8_t new_number_of_week_day_schedules_supported_per_user + ); + + /** +@@ -16341,7 +16341,7 @@ bool dotdot_is_supported_door_lock_number_of_year_day_schedules_supported_per_us + * + * @returns NumberOfYearDaySchedulesSupportedPerUser attribute + */ +-uint8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16361,7 +16361,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_year_day_schedules_supported_per_user ++ int8_t new_number_of_year_day_schedules_supported_per_user + ); + + /** +@@ -16447,7 +16447,7 @@ bool dotdot_is_supported_door_lock_number_of_holiday_schedules_supported ( + * + * @returns NumberOfHolidaySchedulesSupported attribute + */ +-uint8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( ++int8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16467,7 +16467,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_holiday_schedules_supported ++ int8_t new_number_of_holiday_schedules_supported + ); + + /** +@@ -16553,7 +16553,7 @@ bool dotdot_is_supported_door_lock_max_pin_code_length ( + * + * @returns MaxPINCodeLength attribute + */ +-uint8_t dotdot_get_door_lock_max_pin_code_length( ++int8_t dotdot_get_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16573,7 +16573,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_pin_code_length ++ int8_t new_max_pin_code_length + ); + + /** +@@ -16659,7 +16659,7 @@ bool dotdot_is_supported_door_lock_min_pin_code_length ( + * + * @returns MinPINCodeLength attribute + */ +-uint8_t dotdot_get_door_lock_min_pin_code_length( ++int8_t dotdot_get_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16679,7 +16679,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_pin_code_length ++ int8_t new_min_pin_code_length + ); + + /** +@@ -16765,7 +16765,7 @@ bool dotdot_is_supported_door_lock_max_rfid_code_length ( + * + * @returns MaxRFIDCodeLength attribute + */ +-uint8_t dotdot_get_door_lock_max_rfid_code_length( ++int8_t dotdot_get_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16785,7 +16785,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_rfid_code_length ++ int8_t new_max_rfid_code_length + ); + + /** +@@ -16871,7 +16871,7 @@ bool dotdot_is_supported_door_lock_min_rfid_code_length ( + * + * @returns MinRFIDCodeLength attribute + */ +-uint8_t dotdot_get_door_lock_min_rfid_code_length( ++int8_t dotdot_get_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16891,7 +16891,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_rfid_code_length ++ int8_t new_min_rfid_code_length + ); + + /** +@@ -17083,7 +17083,7 @@ bool dotdot_is_supported_door_lock_number_of_credentials_supported_per_user ( + * + * @returns NumberOfCredentialsSupportedPerUser attribute + */ +-uint8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17103,7 +17103,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_credentials_supported_per_user ++ int8_t new_number_of_credentials_supported_per_user + ); + + /** +@@ -17404,7 +17404,7 @@ bool dotdot_is_supported_door_lock_led_settings ( + * + * @returns LEDSettings attribute + */ +-uint8_t dotdot_get_door_lock_led_settings( ++int8_t dotdot_get_door_lock_led_settings( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17424,7 +17424,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_led_settings ++ int8_t new_led_settings + ); + + /** +@@ -17510,7 +17510,7 @@ bool dotdot_is_supported_door_lock_auto_relock_time ( + * + * @returns AutoRelockTime attribute + */ +-uint32_t dotdot_get_door_lock_auto_relock_time( ++int32_t dotdot_get_door_lock_auto_relock_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17530,7 +17530,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_auto_relock_time ++ int32_t new_auto_relock_time + ); + + /** +@@ -17616,7 +17616,7 @@ bool dotdot_is_supported_door_lock_sound_volume ( + * + * @returns SoundVolume attribute + */ +-uint8_t dotdot_get_door_lock_sound_volume( ++int8_t dotdot_get_door_lock_sound_volume( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17636,7 +17636,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_sound_volume ++ int8_t new_sound_volume + ); + + /** +@@ -18570,7 +18570,7 @@ bool dotdot_is_supported_door_lock_wrong_code_entry_limit ( + * + * @returns WrongCodeEntryLimit attribute + */ +-uint8_t dotdot_get_door_lock_wrong_code_entry_limit( ++int8_t dotdot_get_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -18590,7 +18590,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_wrong_code_entry_limit ++ int8_t new_wrong_code_entry_limit + ); + + /** +@@ -18676,7 +18676,7 @@ bool dotdot_is_supported_door_lock_user_code_temporary_disable_time ( + * + * @returns UserCodeTemporaryDisableTime attribute + */ +-uint8_t dotdot_get_door_lock_user_code_temporary_disable_time( ++int8_t dotdot_get_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -18696,7 +18696,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_user_code_temporary_disable_time ++ int8_t new_user_code_temporary_disable_time + ); + + /** +@@ -19100,7 +19100,7 @@ bool dotdot_is_supported_door_lock_expiring_user_timeout ( + * + * @returns ExpiringUserTimeout attribute + */ +-uint16_t dotdot_get_door_lock_expiring_user_timeout( ++int16_t dotdot_get_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -19120,7 +19120,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_expiring_user_timeout ++ int16_t new_expiring_user_timeout + ); + + /** +@@ -20294,7 +20294,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_lift ( + * + * @returns PhysicalClosedLimitLift attribute + */ +-uint16_t dotdot_get_window_covering_physical_closed_limit_lift( ++int16_t dotdot_get_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20314,7 +20314,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit_lift ++ int16_t new_physical_closed_limit_lift + ); + + /** +@@ -20400,7 +20400,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_tilt ( + * + * @returns PhysicalClosedLimitTilt attribute + */ +-uint16_t dotdot_get_window_covering_physical_closed_limit_tilt( ++int16_t dotdot_get_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20420,7 +20420,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit_tilt ++ int16_t new_physical_closed_limit_tilt + ); + + /** +@@ -20506,7 +20506,7 @@ bool dotdot_is_supported_window_covering_current_position_lift ( + * + * @returns CurrentPositionLift attribute + */ +-uint16_t dotdot_get_window_covering_current_position_lift( ++int16_t dotdot_get_window_covering_current_position_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20526,7 +20526,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_position_lift ++ int16_t new_current_position_lift + ); + + /** +@@ -20612,7 +20612,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt ( + * + * @returns CurrentPositionTilt attribute + */ +-uint16_t dotdot_get_window_covering_current_position_tilt( ++int16_t dotdot_get_window_covering_current_position_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20632,7 +20632,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_position_tilt ++ int16_t new_current_position_tilt + ); + + /** +@@ -20718,7 +20718,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_lift ( + * + * @returns NumberOfActuationsLift attribute + */ +-uint16_t dotdot_get_window_covering_number_of_actuations_lift( ++int16_t dotdot_get_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20738,7 +20738,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_actuations_lift ++ int16_t new_number_of_actuations_lift + ); + + /** +@@ -20824,7 +20824,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_tilt ( + * + * @returns NumberOfActuationsTilt attribute + */ +-uint16_t dotdot_get_window_covering_number_of_actuations_tilt( ++int16_t dotdot_get_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20844,7 +20844,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_actuations_tilt ++ int16_t new_number_of_actuations_tilt + ); + + /** +@@ -21036,7 +21036,7 @@ bool dotdot_is_supported_window_covering_current_position_lift_percentage ( + * + * @returns CurrentPositionLiftPercentage attribute + */ +-uint8_t dotdot_get_window_covering_current_position_lift_percentage( ++int8_t dotdot_get_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21056,7 +21056,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_position_lift_percentage ++ int8_t new_current_position_lift_percentage + ); + + /** +@@ -21142,7 +21142,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt_percentage ( + * + * @returns CurrentPositionTiltPercentage attribute + */ +-uint8_t dotdot_get_window_covering_current_position_tilt_percentage( ++int8_t dotdot_get_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21162,7 +21162,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_position_tilt_percentage ++ int8_t new_current_position_tilt_percentage + ); + + /** +@@ -21248,7 +21248,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_lift ( + * + * @returns InstalledOpenLimitLift attribute + */ +-uint16_t dotdot_get_window_covering_installed_open_limit_lift( ++int16_t dotdot_get_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21268,7 +21268,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_open_limit_lift ++ int16_t new_installed_open_limit_lift + ); + + /** +@@ -21354,7 +21354,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_lift ( + * + * @returns InstalledClosedLimitLift attribute + */ +-uint16_t dotdot_get_window_covering_installed_closed_limit_lift( ++int16_t dotdot_get_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21374,7 +21374,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_closed_limit_lift ++ int16_t new_installed_closed_limit_lift + ); + + /** +@@ -21460,7 +21460,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_tilt ( + * + * @returns InstalledOpenLimitTilt attribute + */ +-uint16_t dotdot_get_window_covering_installed_open_limit_tilt( ++int16_t dotdot_get_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21480,7 +21480,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_open_limit_tilt ++ int16_t new_installed_open_limit_tilt + ); + + /** +@@ -21566,7 +21566,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_tilt ( + * + * @returns InstalledClosedLimitTilt attribute + */ +-uint16_t dotdot_get_window_covering_installed_closed_limit_tilt( ++int16_t dotdot_get_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21586,7 +21586,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_closed_limit_tilt ++ int16_t new_installed_closed_limit_tilt + ); + + /** +@@ -21672,7 +21672,7 @@ bool dotdot_is_supported_window_covering_velocity_lift ( + * + * @returns VelocityLift attribute + */ +-uint16_t dotdot_get_window_covering_velocity_lift( ++int16_t dotdot_get_window_covering_velocity_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21692,7 +21692,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_velocity_lift ++ int16_t new_velocity_lift + ); + + /** +@@ -21778,7 +21778,7 @@ bool dotdot_is_supported_window_covering_acceleration_time_lift ( + * + * @returns AccelerationTimeLift attribute + */ +-uint16_t dotdot_get_window_covering_acceleration_time_lift( ++int16_t dotdot_get_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21798,7 +21798,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_acceleration_time_lift ++ int16_t new_acceleration_time_lift + ); + + /** +@@ -21884,7 +21884,7 @@ bool dotdot_is_supported_window_covering_deceleration_time_lift ( + * + * @returns DecelerationTimeLift attribute + */ +-uint16_t dotdot_get_window_covering_deceleration_time_lift( ++int16_t dotdot_get_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21904,7 +21904,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_deceleration_time_lift ++ int16_t new_deceleration_time_lift + ); + + /** +@@ -22099,7 +22099,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_lift ( + * + * @returns IntermediateSetpointsLift attribute + */ +-const char* dotdot_get_window_covering_intermediate_setpoints_lift( ++uint8_t dotdot_get_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22119,7 +22119,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_intermediate_setpoints_lift ++ uint8_t new_intermediate_setpoints_lift + ); + + /** +@@ -22208,7 +22208,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_tilt ( + * + * @returns IntermediateSetpointsTilt attribute + */ +-const char* dotdot_get_window_covering_intermediate_setpoints_tilt( ++uint8_t dotdot_get_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22228,7 +22228,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_intermediate_setpoints_tilt ++ uint8_t new_intermediate_setpoints_tilt + ); + + /** +@@ -22660,7 +22660,7 @@ bool dotdot_is_supported_barrier_control_open_events ( + * + * @returns OpenEvents attribute + */ +-uint16_t dotdot_get_barrier_control_open_events( ++int16_t dotdot_get_barrier_control_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22680,7 +22680,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_events ++ int16_t new_open_events + ); + + /** +@@ -22766,7 +22766,7 @@ bool dotdot_is_supported_barrier_control_close_events ( + * + * @returns CloseEvents attribute + */ +-uint16_t dotdot_get_barrier_control_close_events( ++int16_t dotdot_get_barrier_control_close_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22786,7 +22786,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_close_events ++ int16_t new_close_events + ); + + /** +@@ -22872,7 +22872,7 @@ bool dotdot_is_supported_barrier_control_command_open_events ( + * + * @returns CommandOpenEvents attribute + */ +-uint16_t dotdot_get_barrier_control_command_open_events( ++int16_t dotdot_get_barrier_control_command_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22892,7 +22892,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_command_open_events ++ int16_t new_command_open_events + ); + + /** +@@ -22978,7 +22978,7 @@ bool dotdot_is_supported_barrier_control_command_close_events ( + * + * @returns CommandCloseEvents attribute + */ +-uint16_t dotdot_get_barrier_control_command_close_events( ++int16_t dotdot_get_barrier_control_command_close_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22998,7 +22998,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_command_close_events ++ int16_t new_command_close_events + ); + + /** +@@ -23084,7 +23084,7 @@ bool dotdot_is_supported_barrier_control_open_period ( + * + * @returns OpenPeriod attribute + */ +-uint16_t dotdot_get_barrier_control_open_period( ++int16_t dotdot_get_barrier_control_open_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23104,7 +23104,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_period ++ int16_t new_open_period + ); + + /** +@@ -23190,7 +23190,7 @@ bool dotdot_is_supported_barrier_control_close_period ( + * + * @returns ClosePeriod attribute + */ +-uint16_t dotdot_get_barrier_control_close_period( ++int16_t dotdot_get_barrier_control_close_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23210,7 +23210,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_close_period ++ int16_t new_close_period + ); + + /** +@@ -23296,7 +23296,7 @@ bool dotdot_is_supported_barrier_control_barrier_position ( + * + * @returns BarrierPosition attribute + */ +-uint8_t dotdot_get_barrier_control_barrier_position( ++int8_t dotdot_get_barrier_control_barrier_position( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23316,7 +23316,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_barrier_position ++ int8_t new_barrier_position + ); + + /** +@@ -23536,7 +23536,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_speed ( + * + * @returns MaxSpeed attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_max_speed( ++int16_t dotdot_get_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23556,7 +23556,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_speed ++ int16_t new_max_speed + ); + + /** +@@ -23642,7 +23642,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_flow ( + * + * @returns MaxFlow attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_max_flow( ++int16_t dotdot_get_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23662,7 +23662,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_flow ++ int16_t new_max_flow + ); + + /** +@@ -24172,7 +24172,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_speed ( + * + * @returns MinConstSpeed attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_min_const_speed( ++int16_t dotdot_get_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24192,7 +24192,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_const_speed ++ int16_t new_min_const_speed + ); + + /** +@@ -24278,7 +24278,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_speed ( + * + * @returns MaxConstSpeed attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_max_const_speed( ++int16_t dotdot_get_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24298,7 +24298,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_const_speed ++ int16_t new_max_const_speed + ); + + /** +@@ -24384,7 +24384,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_flow ( + * + * @returns MinConstFlow attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_min_const_flow( ++int16_t dotdot_get_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24404,7 +24404,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_const_flow ++ int16_t new_min_const_flow + ); + + /** +@@ -24490,7 +24490,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_flow ( + * + * @returns MaxConstFlow attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_max_const_flow( ++int16_t dotdot_get_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24510,7 +24510,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_const_flow ++ int16_t new_max_const_flow + ); + + /** +@@ -25232,7 +25232,7 @@ bool dotdot_is_supported_pump_configuration_and_control_speed ( + * + * @returns Speed attribute + */ +-uint16_t dotdot_get_pump_configuration_and_control_speed( ++int16_t dotdot_get_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25252,7 +25252,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_speed ++ int16_t new_speed + ); + + /** +@@ -25338,7 +25338,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_running_hours ( + * + * @returns LifetimeRunningHours attribute + */ +-uint32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( ++int32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25358,7 +25358,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lifetime_running_hours ++ int32_t new_lifetime_running_hours + ); + + /** +@@ -25444,7 +25444,7 @@ bool dotdot_is_supported_pump_configuration_and_control_power ( + * + * @returns Power attribute + */ +-uint32_t dotdot_get_pump_configuration_and_control_power( ++int32_t dotdot_get_pump_configuration_and_control_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25464,7 +25464,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power ++ int32_t new_power + ); + + /** +@@ -25550,7 +25550,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_energy_consumed + * + * @returns LifetimeEnergyConsumed attribute + */ +-uint32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( ++int32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25570,7 +25570,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lifetime_energy_consumed ++ int32_t new_lifetime_energy_consumed + ); + + /** +@@ -26744,7 +26744,7 @@ bool dotdot_is_supported_thermostat_pi_cooling_demand ( + * + * @returns PICoolingDemand attribute + */ +-uint8_t dotdot_get_thermostat_pi_cooling_demand( ++int8_t dotdot_get_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -26764,7 +26764,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pi_cooling_demand ++ int8_t new_pi_cooling_demand + ); + + /** +@@ -26850,7 +26850,7 @@ bool dotdot_is_supported_thermostat_pi_heating_demand ( + * + * @returns PIHeatingDemand attribute + */ +-uint8_t dotdot_get_thermostat_pi_heating_demand( ++int8_t dotdot_get_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -26870,7 +26870,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pi_heating_demand ++ int8_t new_pi_heating_demand + ); + + /** +@@ -28758,7 +28758,7 @@ bool dotdot_is_supported_thermostat_number_of_weekly_transitions ( + * + * @returns NumberOfWeeklyTransitions attribute + */ +-uint8_t dotdot_get_thermostat_number_of_weekly_transitions( ++int8_t dotdot_get_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -28778,7 +28778,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_weekly_transitions ++ int8_t new_number_of_weekly_transitions + ); + + /** +@@ -28864,7 +28864,7 @@ bool dotdot_is_supported_thermostat_number_of_daily_transitions ( + * + * @returns NumberOfDailyTransitions attribute + */ +-uint8_t dotdot_get_thermostat_number_of_daily_transitions( ++int8_t dotdot_get_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -28884,7 +28884,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_daily_transitions ++ int8_t new_number_of_daily_transitions + ); + + /** +@@ -29076,7 +29076,7 @@ bool dotdot_is_supported_thermostat_temperature_setpoint_hold_duration ( + * + * @returns TemperatureSetpointHoldDuration attribute + */ +-uint16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( ++int16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29096,7 +29096,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_temperature_setpoint_hold_duration ++ int16_t new_temperature_setpoint_hold_duration + ); + + /** +@@ -29606,7 +29606,7 @@ bool dotdot_is_supported_thermostat_setpoint_change_source_timestamp ( + * + * @returns SetpointChangeSourceTimestamp attribute + */ +-uint32_t dotdot_get_thermostat_setpoint_change_source_timestamp( ++uint8_t dotdot_get_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29626,7 +29626,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_setpoint_change_source_timestamp ++ uint8_t new_setpoint_change_source_timestamp + ); + + /** +@@ -29712,7 +29712,7 @@ bool dotdot_is_supported_thermostat_occupied_setback ( + * + * @returns OccupiedSetback attribute + */ +-uint8_t dotdot_get_thermostat_occupied_setback( ++int8_t dotdot_get_thermostat_occupied_setback( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29732,7 +29732,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback ++ int8_t new_occupied_setback + ); + + /** +@@ -29818,7 +29818,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_min ( + * + * @returns OccupiedSetbackMin attribute + */ +-uint8_t dotdot_get_thermostat_occupied_setback_min( ++int8_t dotdot_get_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29838,7 +29838,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback_min ++ int8_t new_occupied_setback_min + ); + + /** +@@ -29924,7 +29924,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_max ( + * + * @returns OccupiedSetbackMax attribute + */ +-uint8_t dotdot_get_thermostat_occupied_setback_max( ++int8_t dotdot_get_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29944,7 +29944,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback_max ++ int8_t new_occupied_setback_max + ); + + /** +@@ -30030,7 +30030,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback ( + * + * @returns UnoccupiedSetback attribute + */ +-uint8_t dotdot_get_thermostat_unoccupied_setback( ++int8_t dotdot_get_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30050,7 +30050,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback ++ int8_t new_unoccupied_setback + ); + + /** +@@ -30136,7 +30136,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_min ( + * + * @returns UnoccupiedSetbackMin attribute + */ +-uint8_t dotdot_get_thermostat_unoccupied_setback_min( ++int8_t dotdot_get_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30156,7 +30156,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback_min ++ int8_t new_unoccupied_setback_min + ); + + /** +@@ -30242,7 +30242,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_max ( + * + * @returns UnoccupiedSetbackMax attribute + */ +-uint8_t dotdot_get_thermostat_unoccupied_setback_max( ++int8_t dotdot_get_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30262,7 +30262,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback_max ++ int8_t new_unoccupied_setback_max + ); + + /** +@@ -30348,7 +30348,7 @@ bool dotdot_is_supported_thermostat_emergency_heat_delta ( + * + * @returns EmergencyHeatDelta attribute + */ +-uint8_t dotdot_get_thermostat_emergency_heat_delta( ++int8_t dotdot_get_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30368,7 +30368,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_emergency_heat_delta ++ int8_t new_emergency_heat_delta + ); + + /** +@@ -30560,7 +30560,7 @@ bool dotdot_is_supported_thermostat_ac_capacity ( + * + * @returns ACCapacity attribute + */ +-uint16_t dotdot_get_thermostat_ac_capacity( ++int16_t dotdot_get_thermostat_ac_capacity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30580,7 +30580,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_capacity ++ int16_t new_ac_capacity + ); + + /** +@@ -31570,7 +31570,7 @@ bool dotdot_is_supported_dehumidification_control_relative_humidity ( + * + * @returns RelativeHumidity attribute + */ +-uint8_t dotdot_get_dehumidification_control_relative_humidity( ++int8_t dotdot_get_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31590,7 +31590,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_relative_humidity ++ int8_t new_relative_humidity + ); + + /** +@@ -31676,7 +31676,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_cooling ( + * + * @returns DehumidificationCooling attribute + */ +-uint8_t dotdot_get_dehumidification_control_dehumidification_cooling( ++int8_t dotdot_get_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31696,7 +31696,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_cooling ++ int8_t new_dehumidification_cooling + ); + + /** +@@ -31782,7 +31782,7 @@ bool dotdot_is_supported_dehumidification_control_rh_dehumidification_setpoint ( + * + * @returns RHDehumidificationSetpoint attribute + */ +-uint8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( ++int8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31802,7 +31802,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_rh_dehumidification_setpoint ++ int8_t new_rh_dehumidification_setpoint + ); + + /** +@@ -32100,7 +32100,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_hysteresis ( + * + * @returns DehumidificationHysteresis attribute + */ +-uint8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( ++int8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32120,7 +32120,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_hysteresis ++ int8_t new_dehumidification_hysteresis + ); + + /** +@@ -32206,7 +32206,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_max_cool ( + * + * @returns DehumidificationMaxCool attribute + */ +-uint8_t dotdot_get_dehumidification_control_dehumidification_max_cool( ++int8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32226,7 +32226,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_max_cool ++ int8_t new_dehumidification_max_cool + ); + + /** +@@ -32792,7 +32792,7 @@ bool dotdot_is_supported_color_control_current_hue ( + * + * @returns CurrentHue attribute + */ +-uint8_t dotdot_get_color_control_current_hue( ++int8_t dotdot_get_color_control_current_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32812,7 +32812,7 @@ sl_status_t dotdot_set_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_hue ++ int8_t new_current_hue + ); + + /** +@@ -32898,7 +32898,7 @@ bool dotdot_is_supported_color_control_current_saturation ( + * + * @returns CurrentSaturation attribute + */ +-uint8_t dotdot_get_color_control_current_saturation( ++int8_t dotdot_get_color_control_current_saturation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32918,7 +32918,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_saturation ++ int8_t new_current_saturation + ); + + /** +@@ -33004,7 +33004,7 @@ bool dotdot_is_supported_color_control_remaining_time ( + * + * @returns RemainingTime attribute + */ +-uint16_t dotdot_get_color_control_remaining_time( ++int16_t dotdot_get_color_control_remaining_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33024,7 +33024,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_remaining_time ++ int16_t new_remaining_time + ); + + /** +@@ -33110,7 +33110,7 @@ bool dotdot_is_supported_color_control_currentx ( + * + * @returns CurrentX attribute + */ +-uint16_t dotdot_get_color_control_currentx( ++int16_t dotdot_get_color_control_currentx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33130,7 +33130,7 @@ sl_status_t dotdot_set_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_currentx ++ int16_t new_currentx + ); + + /** +@@ -33216,7 +33216,7 @@ bool dotdot_is_supported_color_control_currenty ( + * + * @returns CurrentY attribute + */ +-uint16_t dotdot_get_color_control_currenty( ++int16_t dotdot_get_color_control_currenty( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33236,7 +33236,7 @@ sl_status_t dotdot_set_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_currenty ++ int16_t new_currenty + ); + + /** +@@ -33537,7 +33537,7 @@ bool dotdot_is_supported_color_control_color_temperature_mireds ( + * + * @returns ColorTemperatureMireds attribute + */ +-uint16_t dotdot_get_color_control_color_temperature_mireds( ++int16_t dotdot_get_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33557,7 +33557,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temperature_mireds ++ int16_t new_color_temperature_mireds + ); + + /** +@@ -33855,7 +33855,7 @@ bool dotdot_is_supported_color_control_number_of_primaries ( + * + * @returns NumberOfPrimaries attribute + */ +-uint8_t dotdot_get_color_control_number_of_primaries( ++int8_t dotdot_get_color_control_number_of_primaries( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33875,7 +33875,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_primaries ++ int8_t new_number_of_primaries + ); + + /** +@@ -33961,7 +33961,7 @@ bool dotdot_is_supported_color_control_primary1x ( + * + * @returns Primary1X attribute + */ +-uint16_t dotdot_get_color_control_primary1x( ++int16_t dotdot_get_color_control_primary1x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33981,7 +33981,7 @@ sl_status_t dotdot_set_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary1x ++ int16_t new_primary1x + ); + + /** +@@ -34067,7 +34067,7 @@ bool dotdot_is_supported_color_control_primary1y ( + * + * @returns Primary1Y attribute + */ +-uint16_t dotdot_get_color_control_primary1y( ++int16_t dotdot_get_color_control_primary1y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34087,7 +34087,7 @@ sl_status_t dotdot_set_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary1y ++ int16_t new_primary1y + ); + + /** +@@ -34173,7 +34173,7 @@ bool dotdot_is_supported_color_control_primary1_intensity ( + * + * @returns Primary1Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary1_intensity( ++int8_t dotdot_get_color_control_primary1_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34193,7 +34193,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary1_intensity ++ int8_t new_primary1_intensity + ); + + /** +@@ -34279,7 +34279,7 @@ bool dotdot_is_supported_color_control_primary2x ( + * + * @returns Primary2X attribute + */ +-uint16_t dotdot_get_color_control_primary2x( ++int16_t dotdot_get_color_control_primary2x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34299,7 +34299,7 @@ sl_status_t dotdot_set_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary2x ++ int16_t new_primary2x + ); + + /** +@@ -34385,7 +34385,7 @@ bool dotdot_is_supported_color_control_primary2y ( + * + * @returns Primary2Y attribute + */ +-uint16_t dotdot_get_color_control_primary2y( ++int16_t dotdot_get_color_control_primary2y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34405,7 +34405,7 @@ sl_status_t dotdot_set_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary2y ++ int16_t new_primary2y + ); + + /** +@@ -34491,7 +34491,7 @@ bool dotdot_is_supported_color_control_primary2_intensity ( + * + * @returns Primary2Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary2_intensity( ++int8_t dotdot_get_color_control_primary2_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34511,7 +34511,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary2_intensity ++ int8_t new_primary2_intensity + ); + + /** +@@ -34597,7 +34597,7 @@ bool dotdot_is_supported_color_control_primary3x ( + * + * @returns Primary3X attribute + */ +-uint16_t dotdot_get_color_control_primary3x( ++int16_t dotdot_get_color_control_primary3x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34617,7 +34617,7 @@ sl_status_t dotdot_set_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary3x ++ int16_t new_primary3x + ); + + /** +@@ -34703,7 +34703,7 @@ bool dotdot_is_supported_color_control_primary3y ( + * + * @returns Primary3Y attribute + */ +-uint16_t dotdot_get_color_control_primary3y( ++int16_t dotdot_get_color_control_primary3y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34723,7 +34723,7 @@ sl_status_t dotdot_set_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary3y ++ int16_t new_primary3y + ); + + /** +@@ -34809,7 +34809,7 @@ bool dotdot_is_supported_color_control_primary3_intensity ( + * + * @returns Primary3Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary3_intensity( ++int8_t dotdot_get_color_control_primary3_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34829,7 +34829,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary3_intensity ++ int8_t new_primary3_intensity + ); + + /** +@@ -34915,7 +34915,7 @@ bool dotdot_is_supported_color_control_primary4x ( + * + * @returns Primary4X attribute + */ +-uint16_t dotdot_get_color_control_primary4x( ++int16_t dotdot_get_color_control_primary4x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34935,7 +34935,7 @@ sl_status_t dotdot_set_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary4x ++ int16_t new_primary4x + ); + + /** +@@ -35021,7 +35021,7 @@ bool dotdot_is_supported_color_control_primary4y ( + * + * @returns Primary4Y attribute + */ +-uint16_t dotdot_get_color_control_primary4y( ++int16_t dotdot_get_color_control_primary4y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35041,7 +35041,7 @@ sl_status_t dotdot_set_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary4y ++ int16_t new_primary4y + ); + + /** +@@ -35127,7 +35127,7 @@ bool dotdot_is_supported_color_control_primary4_intensity ( + * + * @returns Primary4Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary4_intensity( ++int8_t dotdot_get_color_control_primary4_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35147,7 +35147,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary4_intensity ++ int8_t new_primary4_intensity + ); + + /** +@@ -35233,7 +35233,7 @@ bool dotdot_is_supported_color_control_primary5x ( + * + * @returns Primary5X attribute + */ +-uint16_t dotdot_get_color_control_primary5x( ++int16_t dotdot_get_color_control_primary5x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35253,7 +35253,7 @@ sl_status_t dotdot_set_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary5x ++ int16_t new_primary5x + ); + + /** +@@ -35339,7 +35339,7 @@ bool dotdot_is_supported_color_control_primary5y ( + * + * @returns Primary5Y attribute + */ +-uint16_t dotdot_get_color_control_primary5y( ++int16_t dotdot_get_color_control_primary5y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35359,7 +35359,7 @@ sl_status_t dotdot_set_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary5y ++ int16_t new_primary5y + ); + + /** +@@ -35445,7 +35445,7 @@ bool dotdot_is_supported_color_control_primary5_intensity ( + * + * @returns Primary5Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary5_intensity( ++int8_t dotdot_get_color_control_primary5_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35465,7 +35465,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary5_intensity ++ int8_t new_primary5_intensity + ); + + /** +@@ -35551,7 +35551,7 @@ bool dotdot_is_supported_color_control_primary6x ( + * + * @returns Primary6X attribute + */ +-uint16_t dotdot_get_color_control_primary6x( ++int16_t dotdot_get_color_control_primary6x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35571,7 +35571,7 @@ sl_status_t dotdot_set_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary6x ++ int16_t new_primary6x + ); + + /** +@@ -35657,7 +35657,7 @@ bool dotdot_is_supported_color_control_primary6y ( + * + * @returns Primary6Y attribute + */ +-uint16_t dotdot_get_color_control_primary6y( ++int16_t dotdot_get_color_control_primary6y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35677,7 +35677,7 @@ sl_status_t dotdot_set_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary6y ++ int16_t new_primary6y + ); + + /** +@@ -35763,7 +35763,7 @@ bool dotdot_is_supported_color_control_primary6_intensity ( + * + * @returns Primary6Intensity attribute + */ +-uint8_t dotdot_get_color_control_primary6_intensity( ++int8_t dotdot_get_color_control_primary6_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35783,7 +35783,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary6_intensity ++ int8_t new_primary6_intensity + ); + + /** +@@ -35869,7 +35869,7 @@ bool dotdot_is_supported_color_control_white_pointx ( + * + * @returns WhitePointX attribute + */ +-uint16_t dotdot_get_color_control_white_pointx( ++int16_t dotdot_get_color_control_white_pointx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35889,7 +35889,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_white_pointx ++ int16_t new_white_pointx + ); + + /** +@@ -35975,7 +35975,7 @@ bool dotdot_is_supported_color_control_white_pointy ( + * + * @returns WhitePointY attribute + */ +-uint16_t dotdot_get_color_control_white_pointy( ++int16_t dotdot_get_color_control_white_pointy( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35995,7 +35995,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_white_pointy ++ int16_t new_white_pointy + ); + + /** +@@ -36081,7 +36081,7 @@ bool dotdot_is_supported_color_control_color_pointrx ( + * + * @returns ColorPointRX attribute + */ +-uint16_t dotdot_get_color_control_color_pointrx( ++int16_t dotdot_get_color_control_color_pointrx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36101,7 +36101,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointrx ++ int16_t new_color_pointrx + ); + + /** +@@ -36187,7 +36187,7 @@ bool dotdot_is_supported_color_control_color_pointry ( + * + * @returns ColorPointRY attribute + */ +-uint16_t dotdot_get_color_control_color_pointry( ++int16_t dotdot_get_color_control_color_pointry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36207,7 +36207,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointry ++ int16_t new_color_pointry + ); + + /** +@@ -36293,7 +36293,7 @@ bool dotdot_is_supported_color_control_color_pointr_intensity ( + * + * @returns ColorPointRIntensity attribute + */ +-uint8_t dotdot_get_color_control_color_pointr_intensity( ++int8_t dotdot_get_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36313,7 +36313,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointr_intensity ++ int8_t new_color_pointr_intensity + ); + + /** +@@ -36399,7 +36399,7 @@ bool dotdot_is_supported_color_control_color_pointgx ( + * + * @returns ColorPointGX attribute + */ +-uint16_t dotdot_get_color_control_color_pointgx( ++int16_t dotdot_get_color_control_color_pointgx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36419,7 +36419,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointgx ++ int16_t new_color_pointgx + ); + + /** +@@ -36505,7 +36505,7 @@ bool dotdot_is_supported_color_control_color_pointgy ( + * + * @returns ColorPointGY attribute + */ +-uint16_t dotdot_get_color_control_color_pointgy( ++int16_t dotdot_get_color_control_color_pointgy( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36525,7 +36525,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointgy ++ int16_t new_color_pointgy + ); + + /** +@@ -36611,7 +36611,7 @@ bool dotdot_is_supported_color_control_color_pointg_intensity ( + * + * @returns ColorPointGIntensity attribute + */ +-uint8_t dotdot_get_color_control_color_pointg_intensity( ++int8_t dotdot_get_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36631,7 +36631,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointg_intensity ++ int8_t new_color_pointg_intensity + ); + + /** +@@ -36717,7 +36717,7 @@ bool dotdot_is_supported_color_control_color_pointbx ( + * + * @returns ColorPointBX attribute + */ +-uint16_t dotdot_get_color_control_color_pointbx( ++int16_t dotdot_get_color_control_color_pointbx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36737,7 +36737,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointbx ++ int16_t new_color_pointbx + ); + + /** +@@ -36823,7 +36823,7 @@ bool dotdot_is_supported_color_control_color_pointby ( + * + * @returns ColorPointBY attribute + */ +-uint16_t dotdot_get_color_control_color_pointby( ++int16_t dotdot_get_color_control_color_pointby( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36843,7 +36843,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointby ++ int16_t new_color_pointby + ); + + /** +@@ -36929,7 +36929,7 @@ bool dotdot_is_supported_color_control_color_pointb_intensity ( + * + * @returns ColorPointBIntensity attribute + */ +-uint8_t dotdot_get_color_control_color_pointb_intensity( ++int8_t dotdot_get_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36949,7 +36949,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointb_intensity ++ int8_t new_color_pointb_intensity + ); + + /** +@@ -37035,7 +37035,7 @@ bool dotdot_is_supported_color_control_enhanced_current_hue ( + * + * @returns EnhancedCurrentHue attribute + */ +-uint16_t dotdot_get_color_control_enhanced_current_hue( ++int16_t dotdot_get_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37055,7 +37055,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_enhanced_current_hue ++ int16_t new_enhanced_current_hue + ); + + /** +@@ -37247,7 +37247,7 @@ bool dotdot_is_supported_color_control_color_loop_active ( + * + * @returns ColorLoopActive attribute + */ +-uint8_t dotdot_get_color_control_color_loop_active( ++int8_t dotdot_get_color_control_color_loop_active( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37267,7 +37267,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_loop_active ++ int8_t new_color_loop_active + ); + + /** +@@ -37353,7 +37353,7 @@ bool dotdot_is_supported_color_control_color_loop_direction ( + * + * @returns ColorLoopDirection attribute + */ +-uint8_t dotdot_get_color_control_color_loop_direction( ++int8_t dotdot_get_color_control_color_loop_direction( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37373,7 +37373,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_loop_direction ++ int8_t new_color_loop_direction + ); + + /** +@@ -37459,7 +37459,7 @@ bool dotdot_is_supported_color_control_color_loop_time ( + * + * @returns ColorLoopTime attribute + */ +-uint16_t dotdot_get_color_control_color_loop_time( ++int16_t dotdot_get_color_control_color_loop_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37479,7 +37479,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_time ++ int16_t new_color_loop_time + ); + + /** +@@ -37565,7 +37565,7 @@ bool dotdot_is_supported_color_control_color_loop_start_enhanced_hue ( + * + * @returns ColorLoopStartEnhancedHue attribute + */ +-uint16_t dotdot_get_color_control_color_loop_start_enhanced_hue( ++int16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37585,7 +37585,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_start_enhanced_hue ++ int16_t new_color_loop_start_enhanced_hue + ); + + /** +@@ -37671,7 +37671,7 @@ bool dotdot_is_supported_color_control_color_loop_stored_enhanced_hue ( + * + * @returns ColorLoopStoredEnhancedHue attribute + */ +-uint16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( ++int16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37691,7 +37691,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_stored_enhanced_hue ++ int16_t new_color_loop_stored_enhanced_hue + ); + + /** +@@ -37883,7 +37883,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_min_mireds ( + * + * @returns ColorTempPhysicalMinMireds attribute + */ +-uint16_t dotdot_get_color_control_color_temp_physical_min_mireds( ++int16_t dotdot_get_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37903,7 +37903,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temp_physical_min_mireds ++ int16_t new_color_temp_physical_min_mireds + ); + + /** +@@ -37989,7 +37989,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_max_mireds ( + * + * @returns ColorTempPhysicalMaxMireds attribute + */ +-uint16_t dotdot_get_color_control_color_temp_physical_max_mireds( ++int16_t dotdot_get_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38009,7 +38009,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temp_physical_max_mireds ++ int16_t new_color_temp_physical_max_mireds + ); + + /** +@@ -38095,7 +38095,7 @@ bool dotdot_is_supported_color_control_couple_color_temp_to_level_min_mireds ( + * + * @returns CoupleColorTempToLevelMinMireds attribute + */ +-uint16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( ++int16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38115,7 +38115,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_couple_color_temp_to_level_min_mireds ++ int16_t new_couple_color_temp_to_level_min_mireds + ); + + /** +@@ -38201,7 +38201,7 @@ bool dotdot_is_supported_color_control_start_up_color_temperature_mireds ( + * + * @returns StartUpColorTemperatureMireds attribute + */ +-uint16_t dotdot_get_color_control_start_up_color_temperature_mireds( ++int16_t dotdot_get_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38221,7 +38221,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_start_up_color_temperature_mireds ++ int16_t new_start_up_color_temperature_mireds + ); + + /** +@@ -38335,7 +38335,7 @@ bool dotdot_is_supported_ballast_configuration_physical_min_level ( + * + * @returns PhysicalMinLevel attribute + */ +-uint8_t dotdot_get_ballast_configuration_physical_min_level( ++int8_t dotdot_get_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38355,7 +38355,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_min_level ++ int8_t new_physical_min_level + ); + + /** +@@ -38441,7 +38441,7 @@ bool dotdot_is_supported_ballast_configuration_physical_max_level ( + * + * @returns PhysicalMaxLevel attribute + */ +-uint8_t dotdot_get_ballast_configuration_physical_max_level( ++int8_t dotdot_get_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38461,7 +38461,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_max_level ++ int8_t new_physical_max_level + ); + + /** +@@ -38653,7 +38653,7 @@ bool dotdot_is_supported_ballast_configuration_min_level ( + * + * @returns MinLevel attribute + */ +-uint8_t dotdot_get_ballast_configuration_min_level( ++int8_t dotdot_get_ballast_configuration_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38673,7 +38673,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_level ++ int8_t new_min_level + ); + + /** +@@ -38759,7 +38759,7 @@ bool dotdot_is_supported_ballast_configuration_max_level ( + * + * @returns MaxLevel attribute + */ +-uint8_t dotdot_get_ballast_configuration_max_level( ++int8_t dotdot_get_ballast_configuration_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38779,7 +38779,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_level ++ int8_t new_max_level + ); + + /** +@@ -38865,7 +38865,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_level ( + * + * @returns PowerOnLevel attribute + */ +-uint8_t dotdot_get_ballast_configuration_power_on_level( ++int8_t dotdot_get_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38885,7 +38885,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_power_on_level ++ int8_t new_power_on_level + ); + + /** +@@ -38971,7 +38971,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_fade_time ( + * + * @returns PowerOnFadeTime attribute + */ +-uint16_t dotdot_get_ballast_configuration_power_on_fade_time( ++int16_t dotdot_get_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38991,7 +38991,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_power_on_fade_time ++ int16_t new_power_on_fade_time + ); + + /** +@@ -39077,7 +39077,7 @@ bool dotdot_is_supported_ballast_configuration_intrinsic_ballast_factor ( + * + * @returns IntrinsicBallastFactor attribute + */ +-uint8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( ++int8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39097,7 +39097,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intrinsic_ballast_factor ++ int8_t new_intrinsic_ballast_factor + ); + + /** +@@ -39183,7 +39183,7 @@ bool dotdot_is_supported_ballast_configuration_ballast_factor_adjustment ( + * + * @returns BallastFactorAdjustment attribute + */ +-uint8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( ++int8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39203,7 +39203,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_ballast_factor_adjustment ++ int8_t new_ballast_factor_adjustment + ); + + /** +@@ -39289,7 +39289,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_quantity ( + * + * @returns LampQuantity attribute + */ +-uint8_t dotdot_get_ballast_configuration_lamp_quantity( ++int8_t dotdot_get_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39309,7 +39309,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_lamp_quantity ++ int8_t new_lamp_quantity + ); + + /** +@@ -39613,7 +39613,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_rated_hours ( + * + * @returns LampRatedHours attribute + */ +-uint32_t dotdot_get_ballast_configuration_lamp_rated_hours( ++int32_t dotdot_get_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39633,7 +39633,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_rated_hours ++ int32_t new_lamp_rated_hours + ); + + /** +@@ -39719,7 +39719,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours ( + * + * @returns LampBurnHours attribute + */ +-uint32_t dotdot_get_ballast_configuration_lamp_burn_hours( ++int32_t dotdot_get_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39739,7 +39739,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_burn_hours ++ int32_t new_lamp_burn_hours + ); + + /** +@@ -39931,7 +39931,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours_trip_point ( + * + * @returns LampBurnHoursTripPoint attribute + */ +-uint32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( ++int32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39951,7 +39951,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_burn_hours_trip_point ++ int32_t new_lamp_burn_hours_trip_point + ); + + /** +@@ -40065,7 +40065,7 @@ bool dotdot_is_supported_illuminance_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_illuminance_measurement_measured_value( ++int16_t dotdot_get_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40085,7 +40085,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -40171,7 +40171,7 @@ bool dotdot_is_supported_illuminance_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_illuminance_measurement_min_measured_value( ++int16_t dotdot_get_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40191,7 +40191,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -40277,7 +40277,7 @@ bool dotdot_is_supported_illuminance_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_illuminance_measurement_max_measured_value( ++int16_t dotdot_get_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40297,7 +40297,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -40383,7 +40383,7 @@ bool dotdot_is_supported_illuminance_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_illuminance_measurement_tolerance( ++int16_t dotdot_get_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40403,7 +40403,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -40835,7 +40835,7 @@ bool dotdot_is_supported_illuminance_level_sensing_illuminance_target_level ( + * + * @returns IlluminanceTargetLevel attribute + */ +-uint16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( ++int16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40855,7 +40855,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_illuminance_target_level ++ int16_t new_illuminance_target_level + ); + + /** +@@ -41287,7 +41287,7 @@ bool dotdot_is_supported_temperature_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_temperature_measurement_tolerance( ++int16_t dotdot_get_temperature_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -41307,7 +41307,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -41739,7 +41739,7 @@ bool dotdot_is_supported_pressure_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_pressure_measurement_tolerance( ++int16_t dotdot_get_pressure_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -41759,7 +41759,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -42163,7 +42163,7 @@ bool dotdot_is_supported_pressure_measurement_scaled_tolerance ( + * + * @returns ScaledTolerance attribute + */ +-uint16_t dotdot_get_pressure_measurement_scaled_tolerance( ++int16_t dotdot_get_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42183,7 +42183,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_scaled_tolerance ++ int16_t new_scaled_tolerance + ); + + /** +@@ -42403,7 +42403,7 @@ bool dotdot_is_supported_flow_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_flow_measurement_measured_value( ++int16_t dotdot_get_flow_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42423,7 +42423,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -42509,7 +42509,7 @@ bool dotdot_is_supported_flow_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_flow_measurement_min_measured_value( ++int16_t dotdot_get_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42529,7 +42529,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -42615,7 +42615,7 @@ bool dotdot_is_supported_flow_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_flow_measurement_max_measured_value( ++int16_t dotdot_get_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42635,7 +42635,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -42721,7 +42721,7 @@ bool dotdot_is_supported_flow_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_flow_measurement_tolerance( ++int16_t dotdot_get_flow_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42741,7 +42741,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -42855,7 +42855,7 @@ bool dotdot_is_supported_relativity_humidity_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_relativity_humidity_measured_value( ++int16_t dotdot_get_relativity_humidity_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42875,7 +42875,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -42961,7 +42961,7 @@ bool dotdot_is_supported_relativity_humidity_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_relativity_humidity_min_measured_value( ++int16_t dotdot_get_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42981,7 +42981,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -43067,7 +43067,7 @@ bool dotdot_is_supported_relativity_humidity_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_relativity_humidity_max_measured_value( ++int16_t dotdot_get_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43087,7 +43087,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -43173,7 +43173,7 @@ bool dotdot_is_supported_relativity_humidity_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_relativity_humidity_tolerance( ++int16_t dotdot_get_relativity_humidity_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43193,7 +43193,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -43625,7 +43625,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_occupied_to_unoccupied_delay ( + * + * @returns PIROccupiedToUnoccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43645,7 +43645,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_pir_occupied_to_unoccupied_delay ++ int16_t new_pir_occupied_to_unoccupied_delay + ); + + /** +@@ -43731,7 +43731,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_delay ( + * + * @returns PIRUnoccupiedToOccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43751,7 +43751,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_pir_unoccupied_to_occupied_delay ++ int16_t new_pir_unoccupied_to_occupied_delay + ); + + /** +@@ -43837,7 +43837,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_threshold + * + * @returns PIRUnoccupiedToOccupiedThreshold attribute + */ +-uint8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43857,7 +43857,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pir_unoccupied_to_occupied_threshold ++ int8_t new_pir_unoccupied_to_occupied_threshold + ); + + /** +@@ -43943,7 +43943,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_occupied_to_unoccupied_del + * + * @returns UltrasonicOccupiedToUnoccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43963,7 +43963,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ultrasonic_occupied_to_unoccupied_delay ++ int16_t new_ultrasonic_occupied_to_unoccupied_delay + ); + + /** +@@ -44049,7 +44049,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_del + * + * @returns UltrasonicUnoccupiedToOccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44069,7 +44069,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ultrasonic_unoccupied_to_occupied_delay ++ int16_t new_ultrasonic_unoccupied_to_occupied_delay + ); + + /** +@@ -44155,7 +44155,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thr + * + * @returns UltrasonicUnoccupiedToOccupiedThreshold attribute + */ +-uint8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44175,7 +44175,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_ultrasonic_unoccupied_to_occupied_threshold ++ int8_t new_ultrasonic_unoccupied_to_occupied_threshold + ); + + /** +@@ -44261,7 +44261,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_occupied_to_unoccupi + * + * @returns PhysicalContactOccupiedToUnoccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44281,7 +44281,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_contact_occupied_to_unoccupied_delay ++ int16_t new_physical_contact_occupied_to_unoccupied_delay + ); + + /** +@@ -44367,7 +44367,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + * + * @returns PhysicalContactUnoccupiedToOccupiedDelay attribute + */ +-uint16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44387,7 +44387,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_contact_unoccupied_to_occupied_delay ++ int16_t new_physical_contact_unoccupied_to_occupied_delay + ); + + /** +@@ -44473,7 +44473,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + * + * @returns PhysicalContactUnoccupiedToOccupiedThreshold attribute + */ +-uint8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44493,7 +44493,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_contact_unoccupied_to_occupied_threshold ++ int8_t new_physical_contact_unoccupied_to_occupied_threshold + ); + + /** +@@ -44607,7 +44607,7 @@ bool dotdot_is_supported_soil_moisture_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_soil_moisture_measured_value( ++int16_t dotdot_get_soil_moisture_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44627,7 +44627,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -44713,7 +44713,7 @@ bool dotdot_is_supported_soil_moisture_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_soil_moisture_min_measured_value( ++int16_t dotdot_get_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44733,7 +44733,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -44819,7 +44819,7 @@ bool dotdot_is_supported_soil_moisture_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_soil_moisture_max_measured_value( ++int16_t dotdot_get_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44839,7 +44839,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -44925,7 +44925,7 @@ bool dotdot_is_supported_soil_moisture_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_soil_moisture_tolerance( ++int16_t dotdot_get_soil_moisture_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44945,7 +44945,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -45059,7 +45059,7 @@ bool dotdot_is_supported_ph_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_ph_measurement_measured_value( ++int16_t dotdot_get_ph_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45079,7 +45079,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -45165,7 +45165,7 @@ bool dotdot_is_supported_ph_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_ph_measurement_min_measured_value( ++int16_t dotdot_get_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45185,7 +45185,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -45271,7 +45271,7 @@ bool dotdot_is_supported_ph_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_ph_measurement_max_measured_value( ++int16_t dotdot_get_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45291,7 +45291,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -45377,7 +45377,7 @@ bool dotdot_is_supported_ph_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_ph_measurement_tolerance( ++int16_t dotdot_get_ph_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45397,7 +45397,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -45511,7 +45511,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_electrical_conductivity_measurement_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45531,7 +45531,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -45617,7 +45617,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_min_measured_value + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45637,7 +45637,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -45723,7 +45723,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_max_measured_value + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45743,7 +45743,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -45829,7 +45829,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_electrical_conductivity_measurement_tolerance( ++int16_t dotdot_get_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45849,7 +45849,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -45963,7 +45963,7 @@ bool dotdot_is_supported_wind_speed_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-uint16_t dotdot_get_wind_speed_measurement_measured_value( ++int16_t dotdot_get_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45983,7 +45983,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ); + + /** +@@ -46069,7 +46069,7 @@ bool dotdot_is_supported_wind_speed_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-uint16_t dotdot_get_wind_speed_measurement_min_measured_value( ++int16_t dotdot_get_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46089,7 +46089,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ); + + /** +@@ -46175,7 +46175,7 @@ bool dotdot_is_supported_wind_speed_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-uint16_t dotdot_get_wind_speed_measurement_max_measured_value( ++int16_t dotdot_get_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46195,7 +46195,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ); + + /** +@@ -46281,7 +46281,7 @@ bool dotdot_is_supported_wind_speed_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-uint16_t dotdot_get_wind_speed_measurement_tolerance( ++int16_t dotdot_get_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46301,7 +46301,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ); + + /** +@@ -48195,7 +48195,7 @@ bool dotdot_is_supported_ias_zone_zoneid ( + * + * @returns ZoneID attribute + */ +-uint8_t dotdot_get_ias_zone_zoneid( ++int8_t dotdot_get_ias_zone_zoneid( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48215,7 +48215,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_zoneid ++ int8_t new_zoneid + ); + + /** +@@ -48301,7 +48301,7 @@ bool dotdot_is_supported_ias_zone_number_of_zone_sensitivity_levels_supported ( + * + * @returns NumberOfZoneSensitivityLevelsSupported attribute + */ +-uint8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( ++int8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48321,7 +48321,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_zone_sensitivity_levels_supported ++ int8_t new_number_of_zone_sensitivity_levels_supported + ); + + /** +@@ -48407,7 +48407,7 @@ bool dotdot_is_supported_ias_zone_current_zone_sensitivity_level ( + * + * @returns CurrentZoneSensitivityLevel attribute + */ +-uint8_t dotdot_get_ias_zone_current_zone_sensitivity_level( ++int8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48427,7 +48427,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_zone_sensitivity_level ++ int8_t new_current_zone_sensitivity_level + ); + + /** +@@ -48541,7 +48541,7 @@ bool dotdot_is_supported_iaswd_max_duration ( + * + * @returns MaxDuration attribute + */ +-uint16_t dotdot_get_iaswd_max_duration( ++int16_t dotdot_get_iaswd_max_duration( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48561,7 +48561,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_duration ++ int16_t new_max_duration + ); + + /** +@@ -48675,7 +48675,7 @@ bool dotdot_is_supported_metering_current_summation_delivered ( + * + * @returns CurrentSummationDelivered attribute + */ +-uint64_t dotdot_get_metering_current_summation_delivered( ++int64_t dotdot_get_metering_current_summation_delivered( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48695,7 +48695,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_summation_delivered ++ int64_t new_current_summation_delivered + ); + + /** +@@ -48781,7 +48781,7 @@ bool dotdot_is_supported_metering_current_summation_received ( + * + * @returns CurrentSummationReceived attribute + */ +-uint64_t dotdot_get_metering_current_summation_received( ++int64_t dotdot_get_metering_current_summation_received( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48801,7 +48801,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_summation_received ++ int64_t new_current_summation_received + ); + + /** +@@ -48887,7 +48887,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered ( + * + * @returns CurrentMaxDemandDelivered attribute + */ +-uint64_t dotdot_get_metering_current_max_demand_delivered( ++int64_t dotdot_get_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48907,7 +48907,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_max_demand_delivered ++ int64_t new_current_max_demand_delivered + ); + + /** +@@ -49205,7 +49205,7 @@ bool dotdot_is_supported_metering_reading_snap_shot_time ( + * + * @returns ReadingSnapShotTime attribute + */ +-uint32_t dotdot_get_metering_reading_snap_shot_time( ++uint8_t dotdot_get_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49225,7 +49225,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_reading_snap_shot_time ++ uint8_t new_reading_snap_shot_time + ); + + /** +@@ -49311,7 +49311,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered_time ( + * + * @returns CurrentMaxDemandDeliveredTime attribute + */ +-uint32_t dotdot_get_metering_current_max_demand_delivered_time( ++uint8_t dotdot_get_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49331,7 +49331,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_current_max_demand_delivered_time ++ uint8_t new_current_max_demand_delivered_time + ); + + /** +@@ -49417,7 +49417,7 @@ bool dotdot_is_supported_metering_current_max_demand_received_time ( + * + * @returns CurrentMaxDemandReceivedTime attribute + */ +-uint32_t dotdot_get_metering_current_max_demand_received_time( ++uint8_t dotdot_get_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49437,7 +49437,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_current_max_demand_received_time ++ uint8_t new_current_max_demand_received_time + ); + + /** +@@ -49523,7 +49523,7 @@ bool dotdot_is_supported_metering_default_update_period ( + * + * @returns DefaultUpdatePeriod attribute + */ +-uint8_t dotdot_get_metering_default_update_period( ++int8_t dotdot_get_metering_default_update_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49543,7 +49543,7 @@ sl_status_t dotdot_set_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_default_update_period ++ int8_t new_default_update_period + ); + + /** +@@ -49735,7 +49735,7 @@ bool dotdot_is_supported_metering_current_inlet_energy_carrier_summation ( + * + * @returns CurrentInletEnergyCarrierSummation attribute + */ +-uint64_t dotdot_get_metering_current_inlet_energy_carrier_summation( ++int64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49755,7 +49755,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_inlet_energy_carrier_summation ++ int64_t new_current_inlet_energy_carrier_summation + ); + + /** +@@ -49841,7 +49841,7 @@ bool dotdot_is_supported_metering_current_outlet_energy_carrier_summation ( + * + * @returns CurrentOutletEnergyCarrierSummation attribute + */ +-uint64_t dotdot_get_metering_current_outlet_energy_carrier_summation( ++int64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49861,7 +49861,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_outlet_energy_carrier_summation ++ int64_t new_current_outlet_energy_carrier_summation + ); + + /** +@@ -50265,7 +50265,7 @@ bool dotdot_is_supported_metering_multiplier ( + * + * @returns Multiplier attribute + */ +-uint32_t dotdot_get_metering_multiplier( ++int32_t dotdot_get_metering_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -50285,7 +50285,7 @@ sl_status_t dotdot_set_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_multiplier ++ int32_t new_multiplier + ); + + /** +@@ -50371,7 +50371,7 @@ bool dotdot_is_supported_metering_divisor ( + * + * @returns Divisor attribute + */ +-uint32_t dotdot_get_metering_divisor( ++int32_t dotdot_get_metering_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -50391,7 +50391,7 @@ sl_status_t dotdot_set_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_divisor ++ int32_t new_divisor + ); + + /** +@@ -52519,7 +52519,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_multiplier ( + * + * @returns DCVoltageMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52539,7 +52539,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_voltage_multiplier ++ int16_t new_dc_voltage_multiplier + ); + + /** +@@ -52625,7 +52625,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_divisor ( + * + * @returns DCVoltageDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_voltage_divisor( ++int16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52645,7 +52645,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_voltage_divisor ++ int16_t new_dc_voltage_divisor + ); + + /** +@@ -52731,7 +52731,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_multiplier ( + * + * @returns DCCurrentMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_current_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52751,7 +52751,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_current_multiplier ++ int16_t new_dc_current_multiplier + ); + + /** +@@ -52837,7 +52837,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_divisor ( + * + * @returns DCCurrentDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_current_divisor( ++int16_t dotdot_get_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52857,7 +52857,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_current_divisor ++ int16_t new_dc_current_divisor + ); + + /** +@@ -52943,7 +52943,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_multiplier ( + * + * @returns DCPowerMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_power_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52963,7 +52963,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_power_multiplier ++ int16_t new_dc_power_multiplier + ); + + /** +@@ -53049,7 +53049,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_divisor ( + * + * @returns DCPowerDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_dc_power_divisor( ++int16_t dotdot_get_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53069,7 +53069,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_power_divisor ++ int16_t new_dc_power_divisor + ); + + /** +@@ -53155,7 +53155,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency ( + * + * @returns ACFrequency attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_frequency( ++int16_t dotdot_get_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53175,7 +53175,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency ++ int16_t new_ac_frequency + ); + + /** +@@ -53261,7 +53261,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_min ( + * + * @returns ACFrequencyMin attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_frequency_min( ++int16_t dotdot_get_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53281,7 +53281,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_min ++ int16_t new_ac_frequency_min + ); + + /** +@@ -53367,7 +53367,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_max ( + * + * @returns ACFrequencyMax attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_frequency_max( ++int16_t dotdot_get_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53387,7 +53387,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_max ++ int16_t new_ac_frequency_max + ); + + /** +@@ -53473,7 +53473,7 @@ bool dotdot_is_supported_electrical_measurement_neutral_current ( + * + * @returns NeutralCurrent attribute + */ +-uint16_t dotdot_get_electrical_measurement_neutral_current( ++int16_t dotdot_get_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53493,7 +53493,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neutral_current ++ int16_t new_neutral_current + ); + + /** +@@ -53791,7 +53791,7 @@ bool dotdot_is_supported_electrical_measurement_total_apparent_power ( + * + * @returns TotalApparentPower attribute + */ +-uint32_t dotdot_get_electrical_measurement_total_apparent_power( ++int32_t dotdot_get_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53811,7 +53811,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_total_apparent_power ++ int32_t new_total_apparent_power + ); + + /** +@@ -55169,7 +55169,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_multiplier ( + * + * @returns ACFrequencyMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55189,7 +55189,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_multiplier ++ int16_t new_ac_frequency_multiplier + ); + + /** +@@ -55275,7 +55275,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_divisor ( + * + * @returns ACFrequencyDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_frequency_divisor( ++int16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55295,7 +55295,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_divisor ++ int16_t new_ac_frequency_divisor + ); + + /** +@@ -55381,7 +55381,7 @@ bool dotdot_is_supported_electrical_measurement_power_multiplier ( + * + * @returns PowerMultiplier attribute + */ +-uint32_t dotdot_get_electrical_measurement_power_multiplier( ++int32_t dotdot_get_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55401,7 +55401,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power_multiplier ++ int32_t new_power_multiplier + ); + + /** +@@ -55487,7 +55487,7 @@ bool dotdot_is_supported_electrical_measurement_power_divisor ( + * + * @returns PowerDivisor attribute + */ +-uint32_t dotdot_get_electrical_measurement_power_divisor( ++int32_t dotdot_get_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55507,7 +55507,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power_divisor ++ int32_t new_power_divisor + ); + + /** +@@ -55805,7 +55805,7 @@ bool dotdot_is_supported_electrical_measurement_line_current ( + * + * @returns LineCurrent attribute + */ +-uint16_t dotdot_get_electrical_measurement_line_current( ++int16_t dotdot_get_electrical_measurement_line_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55825,7 +55825,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current ++ int16_t new_line_current + ); + + /** +@@ -56123,7 +56123,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage ( + * + * @returns RMSVoltage attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage( ++int16_t dotdot_get_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56143,7 +56143,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage ++ int16_t new_rms_voltage + ); + + /** +@@ -56229,7 +56229,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min ( + * + * @returns RMSVoltageMin attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56249,7 +56249,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min ++ int16_t new_rms_voltage_min + ); + + /** +@@ -56335,7 +56335,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max ( + * + * @returns RMSVoltageMax attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56355,7 +56355,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max ++ int16_t new_rms_voltage_max + ); + + /** +@@ -56441,7 +56441,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current ( + * + * @returns RMSCurrent attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current( ++int16_t dotdot_get_electrical_measurement_rms_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56461,7 +56461,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current ++ int16_t new_rms_current + ); + + /** +@@ -56547,7 +56547,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min ( + * + * @returns RMSCurrentMin attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_min( ++int16_t dotdot_get_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56567,7 +56567,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min ++ int16_t new_rms_current_min + ); + + /** +@@ -56653,7 +56653,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max ( + * + * @returns RMSCurrentMax attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_max( ++int16_t dotdot_get_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56673,7 +56673,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max ++ int16_t new_rms_current_max + ); + + /** +@@ -57183,7 +57183,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power ( + * + * @returns ApparentPower attribute + */ +-uint16_t dotdot_get_electrical_measurement_apparent_power( ++int16_t dotdot_get_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57203,7 +57203,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power ++ int16_t new_apparent_power + ); + + /** +@@ -57395,7 +57395,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriod attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57415,7 +57415,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period ++ int16_t new_average_rms_voltage_measurement_period + ); + + /** +@@ -57501,7 +57501,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounter attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57521,7 +57521,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter ++ int16_t new_average_rms_over_voltage_counter + ); + + /** +@@ -57607,7 +57607,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounter attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57627,7 +57627,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter ++ int16_t new_average_rms_under_voltage_counter + ); + + /** +@@ -57713,7 +57713,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period + * + * @returns RMSExtremeOverVoltagePeriod attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57733,7 +57733,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period ++ int16_t new_rms_extreme_over_voltage_period + ); + + /** +@@ -57819,7 +57819,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriod attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57839,7 +57839,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period ++ int16_t new_rms_extreme_under_voltage_period + ); + + /** +@@ -57925,7 +57925,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period ( + * + * @returns RMSVoltageSagPeriod attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57945,7 +57945,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period ++ int16_t new_rms_voltage_sag_period + ); + + /** +@@ -58031,7 +58031,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period ( + * + * @returns RMSVoltageSwellPeriod attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58051,7 +58051,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period ++ int16_t new_rms_voltage_swell_period + ); + + /** +@@ -58137,7 +58137,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_multiplier ( + * + * @returns ACVoltageMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58157,7 +58157,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_voltage_multiplier ++ int16_t new_ac_voltage_multiplier + ); + + /** +@@ -58243,7 +58243,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_divisor ( + * + * @returns ACVoltageDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_voltage_divisor( ++int16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58263,7 +58263,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_voltage_divisor ++ int16_t new_ac_voltage_divisor + ); + + /** +@@ -58349,7 +58349,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_multiplier ( + * + * @returns ACCurrentMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_current_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58369,7 +58369,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_current_multiplier ++ int16_t new_ac_current_multiplier + ); + + /** +@@ -58455,7 +58455,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_divisor ( + * + * @returns ACCurrentDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_current_divisor( ++int16_t dotdot_get_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58475,7 +58475,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_current_divisor ++ int16_t new_ac_current_divisor + ); + + /** +@@ -58561,7 +58561,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_multiplier ( + * + * @returns ACPowerMultiplier attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_power_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58581,7 +58581,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_power_multiplier ++ int16_t new_ac_power_multiplier + ); + + /** +@@ -58667,7 +58667,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_divisor ( + * + * @returns ACPowerDivisor attribute + */ +-uint16_t dotdot_get_electrical_measurement_ac_power_divisor( ++int16_t dotdot_get_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58687,7 +58687,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_power_divisor ++ int16_t new_ac_power_divisor + ); + + /** +@@ -60257,7 +60257,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phb ( + * + * @returns LineCurrentPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_line_current_phb( ++int16_t dotdot_get_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60277,7 +60277,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current_phb ++ int16_t new_line_current_phb + ); + + /** +@@ -60575,7 +60575,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phb ( + * + * @returns RMSVoltagePhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60595,7 +60595,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_phb ++ int16_t new_rms_voltage_phb + ); + + /** +@@ -60681,7 +60681,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phb ( + * + * @returns RMSVoltageMinPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60701,7 +60701,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min_phb ++ int16_t new_rms_voltage_min_phb + ); + + /** +@@ -60787,7 +60787,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phb ( + * + * @returns RMSVoltageMaxPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60807,7 +60807,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max_phb ++ int16_t new_rms_voltage_max_phb + ); + + /** +@@ -60893,7 +60893,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phb ( + * + * @returns RMSCurrentPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60913,7 +60913,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_phb ++ int16_t new_rms_current_phb + ); + + /** +@@ -60999,7 +60999,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phb ( + * + * @returns RMSCurrentMinPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_min_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61019,7 +61019,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min_phb ++ int16_t new_rms_current_min_phb + ); + + /** +@@ -61105,7 +61105,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phb ( + * + * @returns RMSCurrentMaxPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_max_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61125,7 +61125,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max_phb ++ int16_t new_rms_current_max_phb + ); + + /** +@@ -61635,7 +61635,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phb ( + * + * @returns ApparentPowerPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_apparent_power_phb( ++int16_t dotdot_get_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61655,7 +61655,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power_phb ++ int16_t new_apparent_power_phb + ); + + /** +@@ -61847,7 +61847,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriodPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61867,7 +61867,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period_phb ++ int16_t new_average_rms_voltage_measurement_period_phb + ); + + /** +@@ -61953,7 +61953,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounterPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61973,7 +61973,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter_phb ++ int16_t new_average_rms_over_voltage_counter_phb + ); + + /** +@@ -62059,7 +62059,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounterPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62079,7 +62079,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter_phb ++ int16_t new_average_rms_under_voltage_counter_phb + ); + + /** +@@ -62165,7 +62165,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + * + * @returns RMSExtremeOverVoltagePeriodPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62185,7 +62185,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period_phb ++ int16_t new_rms_extreme_over_voltage_period_phb + ); + + /** +@@ -62271,7 +62271,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriodPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62291,7 +62291,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period_phb ++ int16_t new_rms_extreme_under_voltage_period_phb + ); + + /** +@@ -62377,7 +62377,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phb ( + * + * @returns RMSVoltageSagPeriodPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62397,7 +62397,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period_phb ++ int16_t new_rms_voltage_sag_period_phb + ); + + /** +@@ -62483,7 +62483,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phb ( + * + * @returns RMSVoltageSwellPeriodPhB attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62503,7 +62503,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period_phb ++ int16_t new_rms_voltage_swell_period_phb + ); + + /** +@@ -62589,7 +62589,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phc ( + * + * @returns LineCurrentPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_line_current_phc( ++int16_t dotdot_get_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62609,7 +62609,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current_phc ++ int16_t new_line_current_phc + ); + + /** +@@ -62907,7 +62907,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phc ( + * + * @returns RMSVoltagePhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62927,7 +62927,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_phc ++ int16_t new_rms_voltage_phc + ); + + /** +@@ -63013,7 +63013,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phc ( + * + * @returns RMSVoltageMinPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63033,7 +63033,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min_phc ++ int16_t new_rms_voltage_min_phc + ); + + /** +@@ -63119,7 +63119,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phc ( + * + * @returns RMSVoltageMaxPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63139,7 +63139,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max_phc ++ int16_t new_rms_voltage_max_phc + ); + + /** +@@ -63225,7 +63225,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phc ( + * + * @returns RMSCurrentPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63245,7 +63245,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_phc ++ int16_t new_rms_current_phc + ); + + /** +@@ -63331,7 +63331,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phc ( + * + * @returns RMSCurrentMinPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_min_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63351,7 +63351,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min_phc ++ int16_t new_rms_current_min_phc + ); + + /** +@@ -63437,7 +63437,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phc ( + * + * @returns RMSCurrentMaxPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_current_max_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63457,7 +63457,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max_phc ++ int16_t new_rms_current_max_phc + ); + + /** +@@ -63967,7 +63967,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phc ( + * + * @returns ApparentPowerPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_apparent_power_phc( ++int16_t dotdot_get_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63987,7 +63987,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power_phc ++ int16_t new_apparent_power_phc + ); + + /** +@@ -64179,7 +64179,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriodPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64199,7 +64199,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period_phc ++ int16_t new_average_rms_voltage_measurement_period_phc + ); + + /** +@@ -64285,7 +64285,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounterPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64305,7 +64305,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter_phc ++ int16_t new_average_rms_over_voltage_counter_phc + ); + + /** +@@ -64391,7 +64391,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounterPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64411,7 +64411,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter_phc ++ int16_t new_average_rms_under_voltage_counter_phc + ); + + /** +@@ -64497,7 +64497,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + * + * @returns RMSExtremeOverVoltagePeriodPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64517,7 +64517,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period_phc ++ int16_t new_rms_extreme_over_voltage_period_phc + ); + + /** +@@ -64603,7 +64603,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriodPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64623,7 +64623,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period_phc ++ int16_t new_rms_extreme_under_voltage_period_phc + ); + + /** +@@ -64709,7 +64709,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phc ( + * + * @returns RMSVoltageSagPeriodPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64729,7 +64729,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period_phc ++ int16_t new_rms_voltage_sag_period_phc + ); + + /** +@@ -64815,7 +64815,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phc ( + * + * @returns RMSVoltageSwellPeriodPhC attribute + */ +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64835,7 +64835,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period_phc ++ int16_t new_rms_voltage_swell_period_phc + ); + + /** +@@ -64949,7 +64949,7 @@ bool dotdot_is_supported_diagnostics_number_of_resets ( + * + * @returns NumberOfResets attribute + */ +-uint16_t dotdot_get_diagnostics_number_of_resets( ++int16_t dotdot_get_diagnostics_number_of_resets( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64969,7 +64969,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_resets ++ int16_t new_number_of_resets + ); + + /** +@@ -65055,7 +65055,7 @@ bool dotdot_is_supported_diagnostics_persistent_memory_writes ( + * + * @returns PersistentMemoryWrites attribute + */ +-uint16_t dotdot_get_diagnostics_persistent_memory_writes( ++int16_t dotdot_get_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65075,7 +65075,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_persistent_memory_writes ++ int16_t new_persistent_memory_writes + ); + + /** +@@ -65161,7 +65161,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_bcast ( + * + * @returns MacRxBcast attribute + */ +-uint32_t dotdot_get_diagnostics_mac_rx_bcast( ++int32_t dotdot_get_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65181,7 +65181,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_rx_bcast ++ int32_t new_mac_rx_bcast + ); + + /** +@@ -65267,7 +65267,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_bcast ( + * + * @returns MacTxBcast attribute + */ +-uint32_t dotdot_get_diagnostics_mac_tx_bcast( ++int32_t dotdot_get_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65287,7 +65287,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_tx_bcast ++ int32_t new_mac_tx_bcast + ); + + /** +@@ -65373,7 +65373,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_ucast ( + * + * @returns MacRxUcast attribute + */ +-uint32_t dotdot_get_diagnostics_mac_rx_ucast( ++int32_t dotdot_get_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65393,7 +65393,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_rx_ucast ++ int32_t new_mac_rx_ucast + ); + + /** +@@ -65479,7 +65479,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast ( + * + * @returns MacTxUcast attribute + */ +-uint32_t dotdot_get_diagnostics_mac_tx_ucast( ++int32_t dotdot_get_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65499,7 +65499,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_tx_ucast ++ int32_t new_mac_tx_ucast + ); + + /** +@@ -65585,7 +65585,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_retry ( + * + * @returns MacTxUcastRetry attribute + */ +-uint16_t dotdot_get_diagnostics_mac_tx_ucast_retry( ++int16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65605,7 +65605,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mac_tx_ucast_retry ++ int16_t new_mac_tx_ucast_retry + ); + + /** +@@ -65691,7 +65691,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_fail ( + * + * @returns MacTxUcastFail attribute + */ +-uint16_t dotdot_get_diagnostics_mac_tx_ucast_fail( ++int16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65711,7 +65711,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mac_tx_ucast_fail ++ int16_t new_mac_tx_ucast_fail + ); + + /** +@@ -65797,7 +65797,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_bcast ( + * + * @returns APSRxBcast attribute + */ +-uint16_t dotdot_get_diagnostics_aps_rx_bcast( ++int16_t dotdot_get_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65817,7 +65817,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_rx_bcast ++ int16_t new_aps_rx_bcast + ); + + /** +@@ -65903,7 +65903,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_bcast ( + * + * @returns APSTxBcast attribute + */ +-uint16_t dotdot_get_diagnostics_aps_tx_bcast( ++int16_t dotdot_get_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65923,7 +65923,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_bcast ++ int16_t new_aps_tx_bcast + ); + + /** +@@ -66009,7 +66009,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_ucast ( + * + * @returns APSRxUcast attribute + */ +-uint16_t dotdot_get_diagnostics_aps_rx_ucast( ++int16_t dotdot_get_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66029,7 +66029,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_rx_ucast ++ int16_t new_aps_rx_ucast + ); + + /** +@@ -66115,7 +66115,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_success ( + * + * @returns APSTxUcastSuccess attribute + */ +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_success( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66135,7 +66135,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_success ++ int16_t new_aps_tx_ucast_success + ); + + /** +@@ -66221,7 +66221,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_retry ( + * + * @returns APSTxUcastRetry attribute + */ +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_retry( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66241,7 +66241,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_retry ++ int16_t new_aps_tx_ucast_retry + ); + + /** +@@ -66327,7 +66327,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_fail ( + * + * @returns APSTxUcastFail attribute + */ +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_fail( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66347,7 +66347,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_fail ++ int16_t new_aps_tx_ucast_fail + ); + + /** +@@ -66433,7 +66433,7 @@ bool dotdot_is_supported_diagnostics_route_disc_initiated ( + * + * @returns RouteDiscInitiated attribute + */ +-uint16_t dotdot_get_diagnostics_route_disc_initiated( ++int16_t dotdot_get_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66453,7 +66453,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_route_disc_initiated ++ int16_t new_route_disc_initiated + ); + + /** +@@ -66539,7 +66539,7 @@ bool dotdot_is_supported_diagnostics_neighbor_added ( + * + * @returns NeighborAdded attribute + */ +-uint16_t dotdot_get_diagnostics_neighbor_added( ++int16_t dotdot_get_diagnostics_neighbor_added( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66559,7 +66559,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_added ++ int16_t new_neighbor_added + ); + + /** +@@ -66645,7 +66645,7 @@ bool dotdot_is_supported_diagnostics_neighbor_removed ( + * + * @returns NeighborRemoved attribute + */ +-uint16_t dotdot_get_diagnostics_neighbor_removed( ++int16_t dotdot_get_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66665,7 +66665,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_removed ++ int16_t new_neighbor_removed + ); + + /** +@@ -66751,7 +66751,7 @@ bool dotdot_is_supported_diagnostics_neighbor_stale ( + * + * @returns NeighborStale attribute + */ +-uint16_t dotdot_get_diagnostics_neighbor_stale( ++int16_t dotdot_get_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66771,7 +66771,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_stale ++ int16_t new_neighbor_stale + ); + + /** +@@ -66857,7 +66857,7 @@ bool dotdot_is_supported_diagnostics_join_indication ( + * + * @returns JoinIndication attribute + */ +-uint16_t dotdot_get_diagnostics_join_indication( ++int16_t dotdot_get_diagnostics_join_indication( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66877,7 +66877,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_join_indication ++ int16_t new_join_indication + ); + + /** +@@ -66963,7 +66963,7 @@ bool dotdot_is_supported_diagnostics_child_moved ( + * + * @returns ChildMoved attribute + */ +-uint16_t dotdot_get_diagnostics_child_moved( ++int16_t dotdot_get_diagnostics_child_moved( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66983,7 +66983,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_child_moved ++ int16_t new_child_moved + ); + + /** +@@ -67069,7 +67069,7 @@ bool dotdot_is_supported_diagnostics_nwkfc_failure ( + * + * @returns NWKFCFailure attribute + */ +-uint16_t dotdot_get_diagnostics_nwkfc_failure( ++int16_t dotdot_get_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67089,7 +67089,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_nwkfc_failure ++ int16_t new_nwkfc_failure + ); + + /** +@@ -67175,7 +67175,7 @@ bool dotdot_is_supported_diagnostics_apsfc_failure ( + * + * @returns APSFCFailure attribute + */ +-uint16_t dotdot_get_diagnostics_apsfc_failure( ++int16_t dotdot_get_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67195,7 +67195,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apsfc_failure ++ int16_t new_apsfc_failure + ); + + /** +@@ -67281,7 +67281,7 @@ bool dotdot_is_supported_diagnostics_aps_unauthorized_key ( + * + * @returns APSUnauthorizedKey attribute + */ +-uint16_t dotdot_get_diagnostics_aps_unauthorized_key( ++int16_t dotdot_get_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67301,7 +67301,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_unauthorized_key ++ int16_t new_aps_unauthorized_key + ); + + /** +@@ -67387,7 +67387,7 @@ bool dotdot_is_supported_diagnostics_nwk_decrypt_failures ( + * + * @returns NWKDecryptFailures attribute + */ +-uint16_t dotdot_get_diagnostics_nwk_decrypt_failures( ++int16_t dotdot_get_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67407,7 +67407,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_nwk_decrypt_failures ++ int16_t new_nwk_decrypt_failures + ); + + /** +@@ -67493,7 +67493,7 @@ bool dotdot_is_supported_diagnostics_aps_decrypt_failures ( + * + * @returns APSDecryptFailures attribute + */ +-uint16_t dotdot_get_diagnostics_aps_decrypt_failures( ++int16_t dotdot_get_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67513,7 +67513,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_decrypt_failures ++ int16_t new_aps_decrypt_failures + ); + + /** +@@ -67599,7 +67599,7 @@ bool dotdot_is_supported_diagnostics_packet_buffer_allocate_failures ( + * + * @returns PacketBufferAllocateFailures attribute + */ +-uint16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( ++int16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67619,7 +67619,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_packet_buffer_allocate_failures ++ int16_t new_packet_buffer_allocate_failures + ); + + /** +@@ -67705,7 +67705,7 @@ bool dotdot_is_supported_diagnostics_relayed_ucast ( + * + * @returns RelayedUcast attribute + */ +-uint16_t dotdot_get_diagnostics_relayed_ucast( ++int16_t dotdot_get_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67725,7 +67725,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_relayed_ucast ++ int16_t new_relayed_ucast + ); + + /** +@@ -67811,7 +67811,7 @@ bool dotdot_is_supported_diagnostics_phy_to_mac_queue_limit_reached ( + * + * @returns PHYToMACQueueLimitReached attribute + */ +-uint16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( ++int16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67831,7 +67831,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_phy_to_mac_queue_limit_reached ++ int16_t new_phy_to_mac_queue_limit_reached + ); + + /** +@@ -67917,7 +67917,7 @@ bool dotdot_is_supported_diagnostics_packet_validate_drop_count ( + * + * @returns PacketValidateDropCount attribute + */ +-uint16_t dotdot_get_diagnostics_packet_validate_drop_count( ++int16_t dotdot_get_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67937,7 +67937,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_packet_validate_drop_count ++ int16_t new_packet_validate_drop_count + ); + + /** +@@ -68023,7 +68023,7 @@ bool dotdot_is_supported_diagnostics_average_mac_retry_per_aps_message_sent ( + * + * @returns AverageMACRetryPerAPSMessageSent attribute + */ +-uint16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( ++int16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68043,7 +68043,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_mac_retry_per_aps_message_sent ++ int16_t new_average_mac_retry_per_aps_message_sent + ); + + /** +@@ -68129,7 +68129,7 @@ bool dotdot_is_supported_diagnostics_last_messagelqi ( + * + * @returns LastMessageLQI attribute + */ +-uint8_t dotdot_get_diagnostics_last_messagelqi( ++int8_t dotdot_get_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68149,7 +68149,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_last_messagelqi ++ int8_t new_last_messagelqi + ); + + /** +@@ -68609,7 +68609,7 @@ bool dotdot_is_supported_state_endpoint_id_list ( + * + * @returns EndpointIdList attribute + */ +-uint8_t dotdot_get_state_endpoint_id_list( ++int8_t dotdot_get_state_endpoint_id_list( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68632,7 +68632,7 @@ sl_status_t dotdot_set_state_endpoint_id_list( + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, + size_t new_endpoint_id_list_count, +- const uint8_t* new_endpoint_id_list ++ const int8_t* new_endpoint_id_list + ); + + /** +@@ -68930,7 +68930,7 @@ bool dotdot_is_supported_state_maximum_command_delay ( + * + * @returns MaximumCommandDelay attribute + */ +-uint32_t dotdot_get_state_maximum_command_delay( ++int32_t dotdot_get_state_maximum_command_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68950,7 +68950,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_maximum_command_delay ++ int32_t new_maximum_command_delay + ); + + /** +@@ -69531,7 +69531,7 @@ bool dotdot_is_supported_system_metrics_reporting_interval_seconds ( + * + * @returns ReportingIntervalSeconds attribute + */ +-uint32_t dotdot_get_system_metrics_reporting_interval_seconds( ++int32_t dotdot_get_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -69551,7 +69551,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_reporting_interval_seconds ++ int32_t new_reporting_interval_seconds + ); + + /** +@@ -71578,7 +71578,7 @@ bool dotdot_is_supported_system_metrics_uptime_minutes ( + * + * @returns UptimeMinutes attribute + */ +-uint64_t dotdot_get_system_metrics_uptime_minutes( ++int64_t dotdot_get_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -71598,7 +71598,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_uptime_minutes ++ int64_t new_uptime_minutes + ); + + /** +@@ -72320,7 +72320,7 @@ bool dotdot_is_supported_system_metrics_system_interrupts ( + * + * @returns SystemInterrupts attribute + */ +-uint64_t dotdot_get_system_metrics_system_interrupts( ++int64_t dotdot_get_system_metrics_system_interrupts( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -72340,7 +72340,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_system_interrupts ++ int64_t new_system_interrupts + ); + + /** +@@ -72890,7 +72890,7 @@ bool dotdot_is_supported_application_monitoring_uptime_minutes ( + * + * @returns UptimeMinutes attribute + */ +-uint64_t dotdot_get_application_monitoring_uptime_minutes( ++int64_t dotdot_get_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -72910,7 +72910,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_uptime_minutes ++ int64_t new_uptime_minutes + ); + + /** +@@ -72996,7 +72996,7 @@ bool dotdot_is_supported_application_monitoring_process_id ( + * + * @returns ProcessId attribute + */ +-uint64_t dotdot_get_application_monitoring_process_id( ++int64_t dotdot_get_application_monitoring_process_id( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73016,7 +73016,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_process_id ++ int64_t new_process_id + ); + + /** +@@ -73532,7 +73532,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_statistics_reporting_interv + * + * @returns MQTTStatisticsReportingIntervalSeconds attribute + */ +-uint32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( ++int32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73552,7 +73552,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mqtt_statistics_reporting_interval_seconds ++ int32_t new_mqtt_statistics_reporting_interval_seconds + ); + + /** +@@ -73638,7 +73638,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_sent ( + * + * @returns MQTTMessagesSent attribute + */ +-uint64_t dotdot_get_application_monitoring_mqtt_messages_sent( ++int64_t dotdot_get_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73658,7 +73658,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_messages_sent ++ int64_t new_mqtt_messages_sent + ); + + /** +@@ -73744,7 +73744,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_received ( + * + * @returns MQTTMessagesReceived attribute + */ +-uint64_t dotdot_get_application_monitoring_mqtt_messages_received( ++int64_t dotdot_get_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73764,7 +73764,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_messages_received ++ int64_t new_mqtt_messages_received + ); + + /** +@@ -73850,7 +73850,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_subscription_count ( + * + * @returns MQTTSubscriptionCount attribute + */ +-uint64_t dotdot_get_application_monitoring_mqtt_subscription_count( ++int64_t dotdot_get_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73870,7 +73870,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_subscription_count ++ int64_t new_mqtt_subscription_count + ); + + /** +@@ -74274,7 +74274,7 @@ bool dotdot_is_supported_application_monitoring_application_statistics_reporting + * + * @returns ApplicationStatisticsReportingIntervalSeconds attribute + */ +-uint32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( ++int32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -74294,7 +74294,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_application_statistics_reporting_interval_seconds ++ int32_t new_application_statistics_reporting_interval_seconds + ); + + /** +@@ -75293,6 +75293,885 @@ bool dotdot_is_any_configuration_parameters_writable_attribute_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id); + ++//////////////////////////////////////////////////////////////////////////////// ++// Start of cluster UserCredential ++//////////////////////////////////////////////////////////////////////////////// ++// UserCredential SupportedUserUniqueIdentifiers ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportedUserUniqueIdentifiers is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportedUserUniqueIdentifiers is supported ++ * @returns false if SupportedUserUniqueIdentifiers is not supported ++ */ ++bool dotdot_is_supported_user_credential_supported_user_unique_identifiers ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportedUserUniqueIdentifiers attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportedUserUniqueIdentifiers attribute ++ */ ++int16_t dotdot_get_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportedUserUniqueIdentifiers attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_supported_user_unique_identifiers new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ int16_t new_supported_user_unique_identifiers ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportedUserUniqueIdentifiers ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_user_unique_identifiers_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportedUserUniqueIdentifiers attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_user_unique_identifiers_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportedUserUniqueIdentifiers attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_user_unique_identifiers_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportedUserUniqueIdentifiers attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_user_unique_identifiers_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportedUserUniqueIdentifiers attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportedCredentialRules ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportedCredentialRules is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportedCredentialRules is supported ++ * @returns false if SupportedCredentialRules is not supported ++ */ ++bool dotdot_is_supported_user_credential_supported_credential_rules ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportedCredentialRules attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportedCredentialRules attribute ++ */ ++uint8_t dotdot_get_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportedCredentialRules attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_supported_credential_rules new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint8_t new_supported_credential_rules ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportedCredentialRules ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_credential_rules_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportedCredentialRules attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_credential_rules_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportedCredentialRules attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_credential_rules_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportedCredentialRules attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_credential_rules_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportedCredentialRules attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportedCredentialTypes ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportedCredentialTypes is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportedCredentialTypes is supported ++ * @returns false if SupportedCredentialTypes is not supported ++ */ ++bool dotdot_is_supported_user_credential_supported_credential_types ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportedCredentialTypes attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportedCredentialTypes attribute ++ */ ++uint16_t dotdot_get_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportedCredentialTypes attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_supported_credential_types new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint16_t new_supported_credential_types ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportedCredentialTypes ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_credential_types_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportedCredentialTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_credential_types_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportedCredentialTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_credential_types_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportedCredentialTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_credential_types_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportedCredentialTypes attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportedUserTypes ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportedUserTypes is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportedUserTypes is supported ++ * @returns false if SupportedUserTypes is not supported ++ */ ++bool dotdot_is_supported_user_credential_supported_user_types ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportedUserTypes attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportedUserTypes attribute ++ */ ++uint16_t dotdot_get_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportedUserTypes attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_supported_user_types new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint16_t new_supported_user_types ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportedUserTypes ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_user_types_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportedUserTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_supported_user_types_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportedUserTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_user_types_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportedUserTypes attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_supported_user_types_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportedUserTypes attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportCredentialChecksum ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportCredentialChecksum is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportCredentialChecksum is supported ++ * @returns false if SupportCredentialChecksum is not supported ++ */ ++bool dotdot_is_supported_user_credential_support_credential_checksum ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportCredentialChecksum attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportCredentialChecksum attribute ++ */ ++bool dotdot_get_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportCredentialChecksum attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_support_credential_checksum new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_credential_checksum ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportCredentialChecksum ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_credential_checksum_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportCredentialChecksum attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_credential_checksum_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportCredentialChecksum attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_credential_checksum_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportCredentialChecksum attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_credential_checksum_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportCredentialChecksum attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportAdminPinCode ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportAdminPinCode is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportAdminPinCode is supported ++ * @returns false if SupportAdminPinCode is not supported ++ */ ++bool dotdot_is_supported_user_credential_support_admin_pin_code ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportAdminPinCode attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportAdminPinCode attribute ++ */ ++bool dotdot_get_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportAdminPinCode attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_support_admin_pin_code new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_admin_pin_code ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportAdminPinCode ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_admin_pin_code_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportAdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_admin_pin_code_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportAdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_admin_pin_code_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportAdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_admin_pin_code_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportAdminPinCode attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential SupportAdminPinCodeDeactivation ++/** ++ * @brief Verifies if the DotDot UserCredential - SupportAdminPinCodeDeactivation is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if SupportAdminPinCodeDeactivation is supported ++ * @returns false if SupportAdminPinCodeDeactivation is not supported ++ */ ++bool dotdot_is_supported_user_credential_support_admin_pin_code_deactivation ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - SupportAdminPinCodeDeactivation attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * ++ * @returns SupportAdminPinCodeDeactivation attribute ++ */ ++bool dotdot_get_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - SupportAdminPinCodeDeactivation attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_support_admin_pin_code_deactivation new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_admin_pin_code_deactivation ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - SupportAdminPinCodeDeactivation ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_admin_pin_code_deactivation_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - SupportAdminPinCodeDeactivation attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_support_admin_pin_code_deactivation_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - SupportAdminPinCodeDeactivation attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_admin_pin_code_deactivation_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - SupportAdminPinCodeDeactivation attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_support_admin_pin_code_deactivation_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - SupportAdminPinCodeDeactivation attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++// UserCredential AdminPinCode ++/** ++ * @brief Verifies if the DotDot UserCredential - AdminPinCode is supported ++ * under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * ++ * @returns true if AdminPinCode is supported ++ * @returns false if AdminPinCode is not supported ++ */ ++bool dotdot_is_supported_user_credential_admin_pin_code ( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Gets the DotDot UserCredential - AdminPinCode attribute value under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to get, ++ * see \ref attribute_store_get_node_attribute_value ++ * ++ * WARNING: This function is not thread safe, if you retrieve a string, read the ++ * value immediately and cache it yourself before invoking another get function. ++ * ++ * ++ * @returns AdminPinCode attribute ++ */ ++const char* dotdot_get_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state); ++ ++/** ++ * @brief Set the DotDot UserCredential - AdminPinCode attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @param value_state value state to write for the node, ++ * see \ref attribute_store_set_node_attribute_value ++ * ++ * @param new_admin_pin_code new value to set ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_set_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ const char* new_admin_pin_code ++ ); ++ ++/** ++ * @brief Undefines the Reported value of the the DotDot UserCredential - AdminPinCode ++ * attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_admin_pin_code_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Undefines the Desired value of the DotDot ++ * UserCredential - AdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_user_credential_admin_pin_code_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the reported value is defined for the DotDot ++ * UserCredential - AdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_admin_pin_code_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if the desired value is defined for the DotDot ++ * UserCredential - AdminPinCode attribute under a UNID/EndpointID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if defined, false is undefined or non-existent ++ */ ++bool dotdot_user_credential_admin_pin_code_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Creates a DotDot UserCredential - AdminPinCode attribute under a UNID/EndpoinID ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns sl_status_t SL_STATUS_OK on success ++ */ ++sl_status_t dotdot_create_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if a UNID/Endpoint supports any attribute for the UserCredential ++ * Cluster ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if at least 1 attribute in the Attribute Store, false otherwise ++ */ ++bool dotdot_is_any_user_credential_attribute_supported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ ++/** ++ * @brief Checks if a UNID/Endpoint supports any writable attribute for the ++ * UserCredential Cluster ++ * ++ * @param unid Node's UNID ++ * @param endpoint_id Endpoint ID ++ * @returns true if at least 1 writable attribute in the Attribute Store, false otherwise ++ */ ++bool dotdot_is_any_user_credential_writable_attribute_supported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id); ++ + //////////////////////////////////////////////////////////////////////////////// + // Start of cluster ProtocolController-NetworkManagement + //////////////////////////////////////////////////////////////////////////////// +@@ -77132,7 +78011,7 @@ bool dotdot_is_supported_unify_humidity_control_humidifier_setpoint_precision ( + * + * @returns HumidifierSetpointPrecision attribute + */ +-uint8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -77152,7 +78031,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_humidifier_setpoint_precision ++ int8_t new_humidifier_setpoint_precision + ); + + /** +@@ -77662,7 +78541,7 @@ bool dotdot_is_supported_unify_humidity_control_dehumidifier_setpoint_precision + * + * @returns DehumidifierSetpointPrecision attribute + */ +-uint8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -77682,7 +78561,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidifier_setpoint_precision ++ int8_t new_dehumidifier_setpoint_precision + ); + + /** +@@ -78192,7 +79071,7 @@ bool dotdot_is_supported_unify_humidity_control_auto_setpoint_precision ( + * + * @returns AutoSetpointPrecision attribute + */ +-uint8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -78212,7 +79091,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_auto_setpoint_precision ++ int8_t new_auto_setpoint_precision + ); + + /** +diff --git a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_defined_attribute_types.h b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_defined_attribute_types.h +index 46668d1948..6f3c5b0f35 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_defined_attribute_types.h ++++ b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_defined_attribute_types.h +@@ -769,6 +769,15 @@ DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_NAME , 0xfd060000) + DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION , 0xfd060001) + // Attribute Defines for ConfigurationParameters + DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS , 0xfd070000) ++// Attribute Defines for UserCredential ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS , 0xfd080000) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES , 0xfd080001) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES , 0xfd080002) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES , 0xfd080003) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM , 0xfd080004) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE , 0xfd080005) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION , 0xfd080006) ++DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE , 0xfd080007) + // Attribute Defines for ProtocolController-NetworkManagement + DEFINE_ATTRIBUTE(DOTDOT_ATTRIBUTE_ID_PROTOCOL_CONTROLLER_NETWORK_MANAGEMENT_NETWORK_MANAGEMENT_STATE , 0xfd120001) + // Attribute Defines for Descriptor +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp +index 8446b11a47..ab1a977fa1 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp +@@ -98,28 +98,28 @@ static void basic_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION) { + uic_mqtt_dotdot_basic_zcl_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION) { + uic_mqtt_dotdot_basic_application_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION) { + uic_mqtt_dotdot_basic_stack_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION) { + uic_mqtt_dotdot_basic_hw_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -172,7 +172,7 @@ static void basic_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_basic_product_code_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -501,28 +501,28 @@ static void basic_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION) { + uic_mqtt_dotdot_basic_zcl_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION) { + uic_mqtt_dotdot_basic_application_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION) { + uic_mqtt_dotdot_basic_stack_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION) { + uic_mqtt_dotdot_basic_hw_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -575,7 +575,7 @@ static void basic_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_basic_product_code_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -773,14 +773,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY) { + uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -794,35 +794,35 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -844,21 +844,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING) { + uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -872,56 +872,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -935,14 +935,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -964,21 +964,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -992,56 +992,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1055,14 +1055,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1084,21 +1084,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1112,56 +1112,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1709,14 +1709,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY) { + uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1730,35 +1730,35 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1780,21 +1780,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING) { + uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1808,56 +1808,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1871,14 +1871,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1900,21 +1900,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1928,56 +1928,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1991,14 +1991,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2020,21 +2020,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2048,56 +2048,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2247,7 +2247,7 @@ static void device_temperature_configuration_cluster_publish_desired_value_callb + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL) { + uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2275,14 +2275,14 @@ static void device_temperature_configuration_cluster_publish_desired_value_callb + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2460,7 +2460,7 @@ static void device_temperature_configuration_cluster_publish_reported_value_call + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL) { + uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2488,14 +2488,14 @@ static void device_temperature_configuration_cluster_publish_reported_value_call + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2617,7 +2617,7 @@ static void identify_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME) { + uic_mqtt_dotdot_identify_identify_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2710,7 +2710,7 @@ static void identify_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME) { + uic_mqtt_dotdot_identify_identify_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3047,21 +3047,21 @@ static void scenes_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT) { + uic_mqtt_dotdot_scenes_scene_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE) { + uic_mqtt_dotdot_scenes_current_scene_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP) { + uic_mqtt_dotdot_scenes_current_group_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3226,21 +3226,21 @@ static void scenes_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT) { + uic_mqtt_dotdot_scenes_scene_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE) { + uic_mqtt_dotdot_scenes_current_scene_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP) { + uic_mqtt_dotdot_scenes_current_group_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3400,14 +3400,14 @@ static void on_off_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME) { + uic_mqtt_dotdot_on_off_on_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME) { + uic_mqtt_dotdot_on_off_off_wait_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3553,14 +3553,14 @@ static void on_off_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME) { + uic_mqtt_dotdot_on_off_on_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME) { + uic_mqtt_dotdot_on_off_off_wait_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3689,49 +3689,49 @@ static void level_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_current_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME) { + uic_mqtt_dotdot_level_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL) { + uic_mqtt_dotdot_level_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL) { + uic_mqtt_dotdot_level_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY) { + uic_mqtt_dotdot_level_current_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY) { + uic_mqtt_dotdot_level_min_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY) { + uic_mqtt_dotdot_level_max_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3745,42 +3745,42 @@ static void level_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL) { + uic_mqtt_dotdot_level_on_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE) { + uic_mqtt_dotdot_level_default_move_rate_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_start_up_current_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3977,49 +3977,49 @@ static void level_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_current_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME) { + uic_mqtt_dotdot_level_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL) { + uic_mqtt_dotdot_level_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL) { + uic_mqtt_dotdot_level_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY) { + uic_mqtt_dotdot_level_current_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY) { + uic_mqtt_dotdot_level_min_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY) { + uic_mqtt_dotdot_level_max_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4033,42 +4033,42 @@ static void level_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL) { + uic_mqtt_dotdot_level_on_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE) { + uic_mqtt_dotdot_level_default_move_rate_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_start_up_current_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4190,7 +4190,7 @@ static void alarms_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT) { + uic_mqtt_dotdot_alarms_alarm_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4283,7 +4283,7 @@ static void alarms_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT) { + uic_mqtt_dotdot_alarms_alarm_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4405,7 +4405,7 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_TIME) { + uic_mqtt_dotdot_time_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4426,14 +4426,14 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_START) { + uic_mqtt_dotdot_time_dst_start_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_END) { + uic_mqtt_dotdot_time_dst_end_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4447,28 +4447,28 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME) { + uic_mqtt_dotdot_time_standard_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME) { + uic_mqtt_dotdot_time_local_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME) { + uic_mqtt_dotdot_time_last_set_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME) { + uic_mqtt_dotdot_time_valid_until_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4633,7 +4633,7 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_TIME) { + uic_mqtt_dotdot_time_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4654,14 +4654,14 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_START) { + uic_mqtt_dotdot_time_dst_start_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_END) { + uic_mqtt_dotdot_time_dst_end_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4675,28 +4675,28 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME) { + uic_mqtt_dotdot_time_standard_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME) { + uic_mqtt_dotdot_time_local_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME) { + uic_mqtt_dotdot_time_last_set_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME) { + uic_mqtt_dotdot_time_valid_until_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4818,49 +4818,49 @@ static void poll_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL) { + uic_mqtt_dotdot_poll_control_check_in_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5001,49 +5001,49 @@ static void poll_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL) { + uic_mqtt_dotdot_poll_control_check_in_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5165,14 +5165,14 @@ static void shade_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE) { + uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5186,7 +5186,7 @@ static void shade_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5318,14 +5318,14 @@ static void shade_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE) { + uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5339,7 +5339,7 @@ static void shade_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5496,98 +5496,98 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS) { + uic_mqtt_dotdot_door_lock_door_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS) { + uic_mqtt_dotdot_door_lock_door_closed_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD) { + uic_mqtt_dotdot_door_lock_open_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5601,7 +5601,7 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5623,21 +5623,21 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS) { + uic_mqtt_dotdot_door_lock_led_settings_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME) { + uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME) { + uic_mqtt_dotdot_door_lock_sound_volume_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5700,14 +5700,14 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT) { + uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME) { + uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5735,7 +5735,7 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT) { + uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6295,98 +6295,98 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS) { + uic_mqtt_dotdot_door_lock_door_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS) { + uic_mqtt_dotdot_door_lock_door_closed_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD) { + uic_mqtt_dotdot_door_lock_open_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6400,7 +6400,7 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6422,21 +6422,21 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS) { + uic_mqtt_dotdot_door_lock_led_settings_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME) { + uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME) { + uic_mqtt_dotdot_door_lock_sound_volume_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6499,14 +6499,14 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT) { + uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME) { + uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6534,7 +6534,7 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT) { + uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6726,42 +6726,42 @@ static void window_covering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT) { + uic_mqtt_dotdot_window_covering_current_position_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT) { + uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6775,63 +6775,63 @@ static void window_covering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT) { + uic_mqtt_dotdot_window_covering_velocity_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6846,7 +6846,7 @@ static void window_covering_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6854,7 +6854,7 @@ static void window_covering_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7106,42 +7106,42 @@ static void window_covering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT) { + uic_mqtt_dotdot_window_covering_current_position_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT) { + uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7155,63 +7155,63 @@ static void window_covering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT) { + uic_mqtt_dotdot_window_covering_velocity_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7226,7 +7226,7 @@ static void window_covering_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7234,7 +7234,7 @@ static void window_covering_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7377,49 +7377,49 @@ static void barrier_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_close_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_close_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD) { + uic_mqtt_dotdot_barrier_control_open_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD) { + uic_mqtt_dotdot_barrier_control_close_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION) { + uic_mqtt_dotdot_barrier_control_barrier_position_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7605,49 +7605,49 @@ static void barrier_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_close_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_close_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD) { + uic_mqtt_dotdot_barrier_control_open_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD) { + uic_mqtt_dotdot_barrier_control_close_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION) { + uic_mqtt_dotdot_barrier_control_barrier_position_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7776,14 +7776,14 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7818,28 +7818,28 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7888,28 +7888,28 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER) { + uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8214,14 +8214,14 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8256,28 +8256,28 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8326,28 +8326,28 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER) { + uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8539,14 +8539,14 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8672,14 +8672,14 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8693,7 +8693,7 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION) { + uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8728,56 +8728,56 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP) { + uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_occupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA) { + uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8791,7 +8791,7 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY) { + uic_mqtt_dotdot_thermostat_ac_capacity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -9367,14 +9367,14 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9500,14 +9500,14 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9521,7 +9521,7 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION) { + uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9556,56 +9556,56 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP) { + uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_occupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA) { + uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9619,7 +9619,7 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY) { + uic_mqtt_dotdot_thermostat_ac_capacity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10020,21 +10020,21 @@ static void dehumidification_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY) { + uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT) { + uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10055,14 +10055,14 @@ static void dehumidification_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10218,21 +10218,21 @@ static void dehumidification_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY) { + uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT) { + uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10253,14 +10253,14 @@ static void dehumidification_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10648,35 +10648,35 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION) { + uic_mqtt_dotdot_color_control_current_saturation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME) { + uic_mqtt_dotdot_color_control_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX) { + uic_mqtt_dotdot_color_control_currentx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY) { + uic_mqtt_dotdot_color_control_currenty_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10698,7 +10698,7 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10719,217 +10719,217 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES) { + uic_mqtt_dotdot_color_control_number_of_primaries_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X) { + uic_mqtt_dotdot_color_control_primary1x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y) { + uic_mqtt_dotdot_color_control_primary1y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY) { + uic_mqtt_dotdot_color_control_primary1_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X) { + uic_mqtt_dotdot_color_control_primary2x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y) { + uic_mqtt_dotdot_color_control_primary2y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY) { + uic_mqtt_dotdot_color_control_primary2_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X) { + uic_mqtt_dotdot_color_control_primary3x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y) { + uic_mqtt_dotdot_color_control_primary3y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY) { + uic_mqtt_dotdot_color_control_primary3_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X) { + uic_mqtt_dotdot_color_control_primary4x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y) { + uic_mqtt_dotdot_color_control_primary4y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY) { + uic_mqtt_dotdot_color_control_primary4_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X) { + uic_mqtt_dotdot_color_control_primary5x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y) { + uic_mqtt_dotdot_color_control_primary5y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY) { + uic_mqtt_dotdot_color_control_primary5_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X) { + uic_mqtt_dotdot_color_control_primary6x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y) { + uic_mqtt_dotdot_color_control_primary6y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY) { + uic_mqtt_dotdot_color_control_primary6_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX) { + uic_mqtt_dotdot_color_control_white_pointx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY) { + uic_mqtt_dotdot_color_control_white_pointy_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX) { + uic_mqtt_dotdot_color_control_color_pointrx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY) { + uic_mqtt_dotdot_color_control_color_pointry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX) { + uic_mqtt_dotdot_color_control_color_pointgx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY) { + uic_mqtt_dotdot_color_control_color_pointgy_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX) { + uic_mqtt_dotdot_color_control_color_pointbx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY) { + uic_mqtt_dotdot_color_control_color_pointby_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10943,35 +10943,35 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE) { + uic_mqtt_dotdot_color_control_color_loop_active_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION) { + uic_mqtt_dotdot_color_control_color_loop_direction_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME) { + uic_mqtt_dotdot_color_control_color_loop_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10985,28 +10985,28 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -11507,35 +11507,35 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION) { + uic_mqtt_dotdot_color_control_current_saturation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME) { + uic_mqtt_dotdot_color_control_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX) { + uic_mqtt_dotdot_color_control_currentx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY) { + uic_mqtt_dotdot_color_control_currenty_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11557,7 +11557,7 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11578,217 +11578,217 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES) { + uic_mqtt_dotdot_color_control_number_of_primaries_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X) { + uic_mqtt_dotdot_color_control_primary1x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y) { + uic_mqtt_dotdot_color_control_primary1y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY) { + uic_mqtt_dotdot_color_control_primary1_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X) { + uic_mqtt_dotdot_color_control_primary2x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y) { + uic_mqtt_dotdot_color_control_primary2y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY) { + uic_mqtt_dotdot_color_control_primary2_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X) { + uic_mqtt_dotdot_color_control_primary3x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y) { + uic_mqtt_dotdot_color_control_primary3y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY) { + uic_mqtt_dotdot_color_control_primary3_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X) { + uic_mqtt_dotdot_color_control_primary4x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y) { + uic_mqtt_dotdot_color_control_primary4y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY) { + uic_mqtt_dotdot_color_control_primary4_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X) { + uic_mqtt_dotdot_color_control_primary5x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y) { + uic_mqtt_dotdot_color_control_primary5y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY) { + uic_mqtt_dotdot_color_control_primary5_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X) { + uic_mqtt_dotdot_color_control_primary6x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y) { + uic_mqtt_dotdot_color_control_primary6y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY) { + uic_mqtt_dotdot_color_control_primary6_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX) { + uic_mqtt_dotdot_color_control_white_pointx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY) { + uic_mqtt_dotdot_color_control_white_pointy_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX) { + uic_mqtt_dotdot_color_control_color_pointrx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY) { + uic_mqtt_dotdot_color_control_color_pointry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX) { + uic_mqtt_dotdot_color_control_color_pointgx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY) { + uic_mqtt_dotdot_color_control_color_pointgy_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX) { + uic_mqtt_dotdot_color_control_color_pointbx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY) { + uic_mqtt_dotdot_color_control_color_pointby_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11802,35 +11802,35 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE) { + uic_mqtt_dotdot_color_control_color_loop_active_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION) { + uic_mqtt_dotdot_color_control_color_loop_direction_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME) { + uic_mqtt_dotdot_color_control_color_loop_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11844,28 +11844,28 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11987,14 +11987,14 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12008,49 +12008,49 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME) { + uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR) { + uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT) { + uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY) { + uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12073,14 +12073,14 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12094,7 +12094,7 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12307,14 +12307,14 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12328,49 +12328,49 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME) { + uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR) { + uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT) { + uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY) { + uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12393,14 +12393,14 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12414,7 +12414,7 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12536,28 +12536,28 @@ static void illuminance_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12689,28 +12689,28 @@ static void illuminance_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12853,7 +12853,7 @@ static void illuminance_level_sensing_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL) { + uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12976,7 +12976,7 @@ static void illuminance_level_sensing_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL) { + uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13119,7 +13119,7 @@ static void temperature_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13257,7 +13257,7 @@ static void temperature_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13400,7 +13400,7 @@ static void pressure_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13428,7 +13428,7 @@ static void pressure_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13613,7 +13613,7 @@ static void pressure_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13641,7 +13641,7 @@ static void pressure_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13770,28 +13770,28 @@ static void flow_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_flow_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13908,28 +13908,28 @@ static void flow_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_flow_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14051,28 +14051,28 @@ static void relativity_humidity_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE) { + uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14189,28 +14189,28 @@ static void relativity_humidity_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE) { + uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14353,63 +14353,63 @@ static void occupancy_sensing_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14611,63 +14611,63 @@ static void occupancy_sensing_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14789,28 +14789,28 @@ static void soil_moisture_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE) { + uic_mqtt_dotdot_soil_moisture_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14927,28 +14927,28 @@ static void soil_moisture_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE) { + uic_mqtt_dotdot_soil_moisture_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15070,28 +15070,28 @@ static void ph_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_ph_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15208,28 +15208,28 @@ static void ph_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_ph_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15351,28 +15351,28 @@ static void electrical_conductivity_measurement_cluster_publish_desired_value_ca + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15489,28 +15489,28 @@ static void electrical_conductivity_measurement_cluster_publish_reported_value_c + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15632,28 +15632,28 @@ static void wind_speed_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15770,28 +15770,28 @@ static void wind_speed_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -16784,21 +16784,21 @@ static void ias_zone_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID) { + uic_mqtt_dotdot_ias_zone_zoneid_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED) { + uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL) { + uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -16967,21 +16967,21 @@ static void ias_zone_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID) { + uic_mqtt_dotdot_ias_zone_zoneid_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED) { + uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL) { + uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17103,7 +17103,7 @@ static void iaswd_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION) { + uic_mqtt_dotdot_iaswd_max_duration_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17196,7 +17196,7 @@ static void iaswd_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION) { + uic_mqtt_dotdot_iaswd_max_duration_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17318,21 +17318,21 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED) { + uic_mqtt_dotdot_metering_current_summation_delivered_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED) { + uic_mqtt_dotdot_metering_current_summation_received_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17353,28 +17353,28 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME) { + uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD) { + uic_mqtt_dotdot_metering_default_update_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17388,14 +17388,14 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17423,14 +17423,14 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER) { + uic_mqtt_dotdot_metering_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR) { + uic_mqtt_dotdot_metering_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17786,21 +17786,21 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED) { + uic_mqtt_dotdot_metering_current_summation_delivered_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED) { + uic_mqtt_dotdot_metering_current_summation_received_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17821,28 +17821,28 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME) { + uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD) { + uic_mqtt_dotdot_metering_default_update_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17856,14 +17856,14 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17891,14 +17891,14 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER) { + uic_mqtt_dotdot_metering_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR) { + uic_mqtt_dotdot_metering_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -18153,70 +18153,70 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18237,7 +18237,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18328,28 +18328,28 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18370,7 +18370,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_line_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18391,42 +18391,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18461,7 +18461,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18475,91 +18475,91 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18664,7 +18664,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18685,42 +18685,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18755,7 +18755,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18769,56 +18769,56 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18839,42 +18839,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18909,7 +18909,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18923,49 +18923,49 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -20136,70 +20136,70 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20220,7 +20220,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20311,28 +20311,28 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20353,7 +20353,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_line_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20374,42 +20374,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20444,7 +20444,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20458,91 +20458,91 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20647,7 +20647,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20668,42 +20668,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20738,7 +20738,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20752,56 +20752,56 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20822,42 +20822,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20892,7 +20892,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20906,49 +20906,49 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -21070,217 +21070,217 @@ static void diagnostics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS) { + uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES) { + uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED) { + uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED) { + uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED) { + uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE) { + uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION) { + uic_mqtt_dotdot_diagnostics_join_indication_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED) { + uic_mqtt_dotdot_diagnostics_child_moved_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY) { + uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES) { + uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST) { + uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED) { + uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT) { + uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT) { + uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI) { + uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -21628,217 +21628,217 @@ static void diagnostics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS) { + uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES) { + uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED) { + uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED) { + uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED) { + uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE) { + uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION) { + uic_mqtt_dotdot_diagnostics_join_indication_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED) { + uic_mqtt_dotdot_diagnostics_child_moved_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY) { + uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES) { + uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST) { + uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED) { + uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT) { + uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT) { + uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI) { + uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -22202,7 +22202,7 @@ static void state_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY) { + uic_mqtt_dotdot_state_maximum_command_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22342,7 +22342,7 @@ static void state_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY) { + uic_mqtt_dotdot_state_maximum_command_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -22701,7 +22701,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22800,7 +22800,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES) { + uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22849,7 +22849,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS) { + uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23145,7 +23145,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23244,7 +23244,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES) { + uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23293,7 +23293,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS) { + uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23432,14 +23432,14 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES) { + uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID) { + uic_mqtt_dotdot_application_monitoring_process_id_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23476,28 +23476,28 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT) { + uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23525,7 +23525,7 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23850,14 +23850,14 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES) { + uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID) { + uic_mqtt_dotdot_application_monitoring_process_id_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23894,28 +23894,28 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT) { + uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23943,7 +23943,7 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -24170,21 +24170,241 @@ static void name_and_location_cluster_publish_reported_value_callback( + if (change == ATTRIBUTE_DELETED) { + // clang-format off + switch(type) { +- case DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_NAME: +- // clang-format on +- sl_log_debug(LOG_TAG, +- "Unretaining NameAndLocation::Name under topic %s", +- base_topic.c_str()); +- // clang-format off +- uic_mqtt_dotdot_name_and_location_name_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); +- break; +- case DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION: ++ case DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_NAME: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining NameAndLocation::Name under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_name_and_location_name_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining NameAndLocation::Location under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_name_and_location_location_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ default: ++ break; ++ } ++ // clang-format on ++ return; ++ } ++ ++ // If the value got updated but undefined, we skip publication ++ if (false == attribute_store_is_reported_defined(updated_node)) { ++ sl_log_debug(LOG_TAG, "Reported value is undefined. Skipping publication"); ++ return; ++ } ++ ++ // Else we assume update case: ++ // clang-format off ++ try { ++ attribute_store::attribute attr(updated_node); ++ if (type == DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_NAME) { ++ std::vector str_desired = attr.reported>(); ++ uic_mqtt_dotdot_name_and_location_name_publish( ++ base_topic.c_str(), ++ static_cast( str_desired.data() ), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION) { ++ std::vector str_desired = attr.reported>(); ++ uic_mqtt_dotdot_name_and_location_location_publish( ++ base_topic.c_str(), ++ static_cast( str_desired.data() ), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ } catch (std::exception &ex) { ++ sl_log_warning(LOG_TAG, "Failed to publish the Reported attribute value: %s", ex.what()); ++ } ++} ++ ++static void name_and_location_cluster_cluster_revision_callback( ++ attribute_store_node_t updated_node, attribute_store_change_t change) ++{ ++ // clang-format on ++ if (false == is_publish_reported_attribute_values_to_mqtt_enabled()) { ++ return; ++ } ++ ++ // Get the UNID and EndPoint, and prepare the basic topic ++ char unid[MAXIMUM_UNID_SIZE] = {}; ++ dotdot_endpoint_id_t endpoint_id = 0; ++ // clang-format off ++ // clang-format on ++ if (SL_STATUS_OK ++ != unify_dotdot_attributes_get_unid_endpoint()(updated_node, ++ unid, ++ &endpoint_id)) { ++ return; ++ } ++ // clang-format off ++ // clang-format on ++ ++ std::string base_topic = "ucl/by-unid/" + std::string(unid); ++ // clang-format off ++ base_topic += "/ep" + std::to_string(endpoint_id); ++ ++ if ((change == ATTRIBUTE_CREATED) || (change == ATTRIBUTE_UPDATED)) { ++ // On attribute creation, make sure to publish the attribute revision for the first time ++ std::string cluster_revision_topic = base_topic + "/NameAndLocation/Attributes/ClusterRevision"; ++ if (uic_mqtt_count_topics(cluster_revision_topic.c_str()) == 0) { ++ uic_mqtt_dotdot_name_and_location_publish_cluster_revision(base_topic.c_str(), 1); ++ } ++ } ++ ++ if (change == ATTRIBUTE_DELETED) { ++ // Check if we just erased the last attribute under a cluster, if yes, unretain ++ // the Cluster revision too. ++ if (false == dotdot_is_any_name_and_location_attribute_supported(unid, endpoint_id)) { ++ base_topic += "/NameAndLocation"; ++ sl_log_debug(LOG_TAG, "No more attributes supported for NameAndLocation cluster for UNID %s Endpoint %d. Unretaining leftover topics at %s",unid, endpoint_id, base_topic.c_str()); ++ uic_mqtt_unretain(base_topic.c_str()); ++ } ++ } ++} ++ ++ ++/** ++ * @brief Publishes the desired value of an updated attribute store node for ++ * the ConfigurationParameters cluster. ++ * @param updated_node Updated attribute store node ++ * @param change Type of change applied ++ */ ++static void configuration_parameters_cluster_publish_desired_value_callback( ++ attribute_store_node_t updated_node, attribute_store_change_t change) ++{ ++ // clang-format on ++ if (false == is_publish_desired_attribute_values_to_mqtt_enabled()) { ++ return; ++ } ++ if (change == ATTRIBUTE_DELETED || change == ATTRIBUTE_CREATED) { ++ return; ++ } ++ // Scene exception: check that the attribute is not under the Scene Table extension, which is a config and not the node's state. ++ if (ATTRIBUTE_STORE_INVALID_NODE ++ != attribute_store_get_first_parent_with_type( ++ updated_node, ++ DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_TABLE)) { ++ return; ++ } ++ ++ // Get the UNID and EndPoint, and prepare the basic topic ++ char unid[MAXIMUM_UNID_SIZE] = {}; ++ // clang-format off ++ // clang-format on ++ dotdot_endpoint_id_t endpoint_id = 0; ++ if (SL_STATUS_OK ++ != unify_dotdot_attributes_get_unid_endpoint()(updated_node, ++ unid, ++ &endpoint_id)) { ++ return; ++ } ++ // clang-format off ++ // clang-format on ++ ++ std::string base_topic = "ucl/by-unid/" + std::string(unid); ++ // clang-format off ++ base_topic += "/ep" + std::to_string(endpoint_id); ++ // clang-format on ++ ++ attribute_store_type_t type = attribute_store_get_node_type(updated_node); ++ if (type == ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE) { ++ sl_log_debug(LOG_TAG, ++ "Warning: Invalid type for Attribute ID %d, " ++ "this should not happen.", ++ updated_node); ++ return; ++ } ++ ++ // If the value got updated but both Reported and Desired undefined, we skip publication ++ if (false == attribute_store_is_reported_defined(updated_node) ++ && false == attribute_store_is_desired_defined(updated_node)) { ++ sl_log_debug(LOG_TAG, ++ "Reported/Desired values are undefined. " ++ "Skipping publication"); ++ return; ++ } ++ ++ // clang-format off ++ try { ++ attribute_store::attribute attr(updated_node); ++ // Skip attribute ConfigurationParameters because it is an array, ++ // we typically don't save them as array in the attribute store. ++ sl_log_debug(LOG_TAG,"Warning: Cannot publish desired value for attribute ConfigurationParameters ConfigurationParameters. Arrays are not supported"); ++ } catch (std::exception &ex) { ++ sl_log_warning(LOG_TAG, "Failed to publish the Desired attribute value: %s", ex.what()); ++ } ++} ++ ++/** ++ * @brief Publishes the reported value of an updated attribute store node for ++ * the ConfigurationParameters cluster. ++ * @param updated_node Updated attribute store node ++ * @param change Type of change applied ++ */ ++static void configuration_parameters_cluster_publish_reported_value_callback( ++ attribute_store_node_t updated_node, attribute_store_change_t change) ++{ ++ // clang-format on ++ if (false == is_publish_reported_attribute_values_to_mqtt_enabled()) { ++ return; ++ } ++ if (change == ATTRIBUTE_CREATED) { ++ return; ++ } ++ // Scene exception: check that the attribute is not under the Scene Table extension, which is a config and not the node's state. ++ if (ATTRIBUTE_STORE_INVALID_NODE ++ != attribute_store_get_first_parent_with_type( ++ updated_node, ++ DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_TABLE)) { ++ return; ++ } ++ ++ // Get the UNID and EndPoint, and prepare the basic topic ++ char unid[MAXIMUM_UNID_SIZE] = {}; ++ // clang-format off ++ // clang-format on ++ dotdot_endpoint_id_t endpoint_id = 0; ++ if (SL_STATUS_OK ++ != unify_dotdot_attributes_get_unid_endpoint()(updated_node, ++ unid, ++ &endpoint_id)) { ++ return; ++ } ++ // clang-format off ++ // clang-format on ++ ++ std::string base_topic = "ucl/by-unid/" + std::string(unid); ++ // clang-format off ++ base_topic += "/ep" + std::to_string(endpoint_id); ++ // clang-format on ++ ++ attribute_store_type_t type = attribute_store_get_node_type(updated_node); ++ if (type == ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE) { ++ sl_log_debug(LOG_TAG, ++ "Warning: Invalid type for Attribute ID %d, " ++ "this should not happen.", ++ updated_node); ++ return; ++ } ++ ++ // Deletion case: ++ if (change == ATTRIBUTE_DELETED) { ++ // clang-format off ++ switch(type) { ++ case DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS: + // clang-format on + sl_log_debug(LOG_TAG, +- "Unretaining NameAndLocation::Location under topic %s", ++ "Unretaining ConfigurationParameters::ConfigurationParameters under topic %s", + base_topic.c_str()); + // clang-format off +- uic_mqtt_dotdot_name_and_location_location_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ uic_mqtt_dotdot_configuration_parameters_configuration_parameters_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); + break; + default: + break; +@@ -24203,28 +24423,15 @@ static void name_and_location_cluster_publish_reported_value_callback( + // clang-format off + try { + attribute_store::attribute attr(updated_node); +- if (type == DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_NAME) { +- std::vector str_desired = attr.reported>(); +- uic_mqtt_dotdot_name_and_location_name_publish( +- base_topic.c_str(), +- static_cast( str_desired.data() ), +- (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); +- return; +- } +- if (type == DOTDOT_ATTRIBUTE_ID_NAME_AND_LOCATION_LOCATION) { +- std::vector str_desired = attr.reported>(); +- uic_mqtt_dotdot_name_and_location_location_publish( +- base_topic.c_str(), +- static_cast( str_desired.data() ), +- (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); +- return; +- } +- } catch (std::exception &ex) { ++ // Skip attribute ConfigurationParameters because it is an array, ++ // we typically don't save them as array in the attribute store. ++ sl_log_debug(LOG_TAG,"Warning: Cannot publish reported value for attribute ConfigurationParameters ConfigurationParameters. Arrays are not supported"); ++ } catch (std::exception &ex) { + sl_log_warning(LOG_TAG, "Failed to publish the Reported attribute value: %s", ex.what()); + } + } + +-static void name_and_location_cluster_cluster_revision_callback( ++static void configuration_parameters_cluster_cluster_revision_callback( + attribute_store_node_t updated_node, attribute_store_change_t change) + { + // clang-format on +@@ -24252,18 +24459,18 @@ static void name_and_location_cluster_cluster_revision_callback( + + if ((change == ATTRIBUTE_CREATED) || (change == ATTRIBUTE_UPDATED)) { + // On attribute creation, make sure to publish the attribute revision for the first time +- std::string cluster_revision_topic = base_topic + "/NameAndLocation/Attributes/ClusterRevision"; ++ std::string cluster_revision_topic = base_topic + "/ConfigurationParameters/Attributes/ClusterRevision"; + if (uic_mqtt_count_topics(cluster_revision_topic.c_str()) == 0) { +- uic_mqtt_dotdot_name_and_location_publish_cluster_revision(base_topic.c_str(), 1); ++ uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(base_topic.c_str(), 1); + } + } + + if (change == ATTRIBUTE_DELETED) { + // Check if we just erased the last attribute under a cluster, if yes, unretain + // the Cluster revision too. +- if (false == dotdot_is_any_name_and_location_attribute_supported(unid, endpoint_id)) { +- base_topic += "/NameAndLocation"; +- sl_log_debug(LOG_TAG, "No more attributes supported for NameAndLocation cluster for UNID %s Endpoint %d. Unretaining leftover topics at %s",unid, endpoint_id, base_topic.c_str()); ++ if (false == dotdot_is_any_configuration_parameters_attribute_supported(unid, endpoint_id)) { ++ base_topic += "/ConfigurationParameters"; ++ sl_log_debug(LOG_TAG, "No more attributes supported for ConfigurationParameters cluster for UNID %s Endpoint %d. Unretaining leftover topics at %s",unid, endpoint_id, base_topic.c_str()); + uic_mqtt_unretain(base_topic.c_str()); + } + } +@@ -24272,11 +24479,11 @@ static void name_and_location_cluster_cluster_revision_callback( + + /** + * @brief Publishes the desired value of an updated attribute store node for +- * the ConfigurationParameters cluster. ++ * the UserCredential cluster. + * @param updated_node Updated attribute store node + * @param change Type of change applied + */ +-static void configuration_parameters_cluster_publish_desired_value_callback( ++static void user_credential_cluster_publish_desired_value_callback( + attribute_store_node_t updated_node, attribute_store_change_t change) + { + // clang-format on +@@ -24334,21 +24541,75 @@ static void configuration_parameters_cluster_publish_desired_value_callback( + // clang-format off + try { + attribute_store::attribute attr(updated_node); +- // Skip attribute ConfigurationParameters because it is an array, +- // we typically don't save them as array in the attribute store. +- sl_log_debug(LOG_TAG,"Warning: Cannot publish desired value for attribute ConfigurationParameters ConfigurationParameters. Arrays are not supported"); +- } catch (std::exception &ex) { ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS) { ++ uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES) { ++ uic_mqtt_dotdot_user_credential_supported_credential_rules_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES) { ++ uic_mqtt_dotdot_user_credential_supported_credential_types_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES) { ++ uic_mqtt_dotdot_user_credential_supported_user_types_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM) { ++ uic_mqtt_dotdot_user_credential_support_credential_checksum_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE) { ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION) { ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_publish( ++ base_topic.c_str(), ++ static_cast(attr.desired_or_reported()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE) { ++ std::vector str_desired = attr.desired_or_reported>(); ++ uic_mqtt_dotdot_user_credential_admin_pin_code_publish( ++ base_topic.c_str(), ++ static_cast(str_desired.data()), ++ UCL_MQTT_PUBLISH_TYPE_DESIRED); ++ return; ++ } ++ } catch (std::exception &ex) { + sl_log_warning(LOG_TAG, "Failed to publish the Desired attribute value: %s", ex.what()); + } + } + + /** + * @brief Publishes the reported value of an updated attribute store node for +- * the ConfigurationParameters cluster. ++ * the UserCredential cluster. + * @param updated_node Updated attribute store node + * @param change Type of change applied + */ +-static void configuration_parameters_cluster_publish_reported_value_callback( ++static void user_credential_cluster_publish_reported_value_callback( + attribute_store_node_t updated_node, attribute_store_change_t change) + { + // clang-format on +@@ -24398,13 +24659,69 @@ static void configuration_parameters_cluster_publish_reported_value_callback( + if (change == ATTRIBUTE_DELETED) { + // clang-format off + switch(type) { +- case DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS: ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS: + // clang-format on + sl_log_debug(LOG_TAG, +- "Unretaining ConfigurationParameters::ConfigurationParameters under topic %s", ++ "Unretaining UserCredential::SupportedUserUniqueIdentifiers under topic %s", + base_topic.c_str()); + // clang-format off +- uic_mqtt_dotdot_configuration_parameters_configuration_parameters_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportedCredentialRules under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_supported_credential_rules_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportedCredentialTypes under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_supported_credential_types_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportedUserTypes under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_supported_user_types_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportCredentialChecksum under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_support_credential_checksum_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportAdminPinCode under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::SupportAdminPinCodeDeactivation under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); ++ break; ++ case DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE: ++ // clang-format on ++ sl_log_debug(LOG_TAG, ++ "Unretaining UserCredential::AdminPinCode under topic %s", ++ base_topic.c_str()); ++ // clang-format off ++ uic_mqtt_dotdot_user_credential_admin_pin_code_unretain(base_topic.c_str(), UCL_MQTT_PUBLISH_TYPE_ALL); + break; + default: + break; +@@ -24423,15 +24740,69 @@ static void configuration_parameters_cluster_publish_reported_value_callback( + // clang-format off + try { + attribute_store::attribute attr(updated_node); +- // Skip attribute ConfigurationParameters because it is an array, +- // we typically don't save them as array in the attribute store. +- sl_log_debug(LOG_TAG,"Warning: Cannot publish reported value for attribute ConfigurationParameters ConfigurationParameters. Arrays are not supported"); +- } catch (std::exception &ex) { ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS) { ++ uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES) { ++ uic_mqtt_dotdot_user_credential_supported_credential_rules_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES) { ++ uic_mqtt_dotdot_user_credential_supported_credential_types_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES) { ++ uic_mqtt_dotdot_user_credential_supported_user_types_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM) { ++ uic_mqtt_dotdot_user_credential_support_credential_checksum_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE) { ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION) { ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_publish( ++ base_topic.c_str(), ++ static_cast(attr.reported()), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE) { ++ std::vector str_desired = attr.reported>(); ++ uic_mqtt_dotdot_user_credential_admin_pin_code_publish( ++ base_topic.c_str(), ++ static_cast( str_desired.data() ), ++ (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); ++ return; ++ } ++ } catch (std::exception &ex) { + sl_log_warning(LOG_TAG, "Failed to publish the Reported attribute value: %s", ex.what()); + } + } + +-static void configuration_parameters_cluster_cluster_revision_callback( ++static void user_credential_cluster_cluster_revision_callback( + attribute_store_node_t updated_node, attribute_store_change_t change) + { + // clang-format on +@@ -24459,18 +24830,18 @@ static void configuration_parameters_cluster_cluster_revision_callback( + + if ((change == ATTRIBUTE_CREATED) || (change == ATTRIBUTE_UPDATED)) { + // On attribute creation, make sure to publish the attribute revision for the first time +- std::string cluster_revision_topic = base_topic + "/ConfigurationParameters/Attributes/ClusterRevision"; ++ std::string cluster_revision_topic = base_topic + "/UserCredential/Attributes/ClusterRevision"; + if (uic_mqtt_count_topics(cluster_revision_topic.c_str()) == 0) { +- uic_mqtt_dotdot_configuration_parameters_publish_cluster_revision(base_topic.c_str(), 1); ++ uic_mqtt_dotdot_user_credential_publish_cluster_revision(base_topic.c_str(), 1); + } + } + + if (change == ATTRIBUTE_DELETED) { + // Check if we just erased the last attribute under a cluster, if yes, unretain + // the Cluster revision too. +- if (false == dotdot_is_any_configuration_parameters_attribute_supported(unid, endpoint_id)) { +- base_topic += "/ConfigurationParameters"; +- sl_log_debug(LOG_TAG, "No more attributes supported for ConfigurationParameters cluster for UNID %s Endpoint %d. Unretaining leftover topics at %s",unid, endpoint_id, base_topic.c_str()); ++ if (false == dotdot_is_any_user_credential_attribute_supported(unid, endpoint_id)) { ++ base_topic += "/UserCredential"; ++ sl_log_debug(LOG_TAG, "No more attributes supported for UserCredential cluster for UNID %s Endpoint %d. Unretaining leftover topics at %s",unid, endpoint_id, base_topic.c_str()); + uic_mqtt_unretain(base_topic.c_str()); + } + } +@@ -25518,7 +25889,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -25553,7 +25924,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -25588,7 +25959,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -25881,7 +26252,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -25916,7 +26287,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -25951,7 +26322,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -35755,6 +36126,118 @@ sl_status_t unify_dotdot_attribute_store_attribute_publisher_init() + configuration_parameters_cluster_cluster_revision_callback, + DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS); + //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ //Desired attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_desired_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE, ++ DESIRED_ATTRIBUTE); ++ //Reported attribute state ++ attribute_store_register_callback_by_type_and_state( ++ user_credential_cluster_publish_reported_value_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE, ++ REPORTED_ATTRIBUTE); ++ //registering a callback when an attribute is created for publishing cluster revision ++ attribute_store_register_callback_by_type( ++ user_credential_cluster_cluster_revision_callback, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ //Desired attribute state + attribute_store_register_callback_by_type_and_state( + protocol_controller_network_management_cluster_publish_desired_value_callback, + DOTDOT_ATTRIBUTE_ID_PROTOCOL_CONTROLLER_NETWORK_MANAGEMENT_NETWORK_MANAGEMENT_STATE, +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_force_read_attributes_command_callbacks.c b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_force_read_attributes_command_callbacks.c +index 8237315595..fe3a605125 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_force_read_attributes_command_callbacks.c ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_force_read_attributes_command_callbacks.c +@@ -4325,6 +4325,71 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_force_read_attribute + return SL_STATUS_OK; + } + //////////////////////////////////////////////////////////////////////////////// ++// Start of cluster UserCredential ++//////////////////////////////////////////////////////////////////////////////// ++static sl_status_t uic_mqtt_dotdot_user_credential_force_read_attributes_callback ( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_user_credential_updated_state_t attribute_list) { ++ ++ if (false == is_force_read_attributes_enabled()){ ++ return SL_STATUS_FAIL; ++ } ++ ++ if (call_type == UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK) { ++ if (is_automatic_deduction_of_supported_commands_enabled()) { ++ return dotdot_is_any_user_credential_attribute_supported(unid, endpoint_id) ? ++ SL_STATUS_OK : SL_STATUS_FAIL; ++ } else { ++ return SL_STATUS_FAIL; ++ } ++ } ++ ++ // Go and undefine everything that needs to be read again: ++ if (true == attribute_list.supported_user_unique_identifiers) { ++ if (SL_STATUS_OK == dotdot_user_credential_supported_user_unique_identifiers_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportedUserUniqueIdentifiers under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.supported_credential_rules) { ++ if (SL_STATUS_OK == dotdot_user_credential_supported_credential_rules_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportedCredentialRules under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.supported_credential_types) { ++ if (SL_STATUS_OK == dotdot_user_credential_supported_credential_types_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportedCredentialTypes under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.supported_user_types) { ++ if (SL_STATUS_OK == dotdot_user_credential_supported_user_types_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportedUserTypes under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.support_credential_checksum) { ++ if (SL_STATUS_OK == dotdot_user_credential_support_credential_checksum_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportCredentialChecksum under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.support_admin_pin_code) { ++ if (SL_STATUS_OK == dotdot_user_credential_support_admin_pin_code_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportAdminPinCode under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.support_admin_pin_code_deactivation) { ++ if (SL_STATUS_OK == dotdot_user_credential_support_admin_pin_code_deactivation_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::SupportAdminPinCodeDeactivation under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ if (true == attribute_list.admin_pin_code) { ++ if (SL_STATUS_OK == dotdot_user_credential_admin_pin_code_undefine_reported(unid, endpoint_id)) { ++ sl_log_debug(LOG_TAG, "Undefined Reported value of UserCredential::AdminPinCode under %s - Endpoint %d", unid, endpoint_id); ++ } ++ } ++ return SL_STATUS_OK; ++} ++//////////////////////////////////////////////////////////////////////////////// + // Start of cluster Descriptor + //////////////////////////////////////////////////////////////////////////////// + static sl_status_t uic_mqtt_dotdot_descriptor_force_read_attributes_callback ( +@@ -4657,6 +4722,8 @@ sl_status_t + + uic_mqtt_dotdot_set_configuration_parameters_force_read_attributes_callback(&uic_mqtt_dotdot_configuration_parameters_force_read_attributes_callback); + ++ uic_mqtt_dotdot_set_user_credential_force_read_attributes_callback(&uic_mqtt_dotdot_user_credential_force_read_attributes_callback); ++ + + uic_mqtt_dotdot_set_descriptor_force_read_attributes_callback(&uic_mqtt_dotdot_descriptor_force_read_attributes_callback); + +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp +index bbcc3f7fad..0b8fc63e13 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp +@@ -40,7 +40,7 @@ bool dotdot_is_supported_basic_zcl_version( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_basic_zcl_version( ++int8_t dotdot_get_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -51,7 +51,7 @@ uint8_t dotdot_get_basic_zcl_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -63,7 +63,7 @@ sl_status_t dotdot_set_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_zcl_version ++ int8_t new_zcl_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -76,7 +76,7 @@ sl_status_t dotdot_set_basic_zcl_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_zcl_version, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_basic_zcl_version_undefine_reported( +@@ -151,7 +151,7 @@ bool dotdot_is_supported_basic_application_version( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_basic_application_version( ++int8_t dotdot_get_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -162,7 +162,7 @@ uint8_t dotdot_get_basic_application_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -174,7 +174,7 @@ sl_status_t dotdot_set_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_application_version ++ int8_t new_application_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -187,7 +187,7 @@ sl_status_t dotdot_set_basic_application_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_application_version, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_basic_application_version_undefine_reported( +@@ -262,7 +262,7 @@ bool dotdot_is_supported_basic_stack_version( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_basic_stack_version( ++int8_t dotdot_get_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -273,7 +273,7 @@ uint8_t dotdot_get_basic_stack_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -285,7 +285,7 @@ sl_status_t dotdot_set_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_stack_version ++ int8_t new_stack_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -298,7 +298,7 @@ sl_status_t dotdot_set_basic_stack_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_stack_version, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_basic_stack_version_undefine_reported( +@@ -373,7 +373,7 @@ bool dotdot_is_supported_basic_hw_version( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_basic_hw_version( ++int8_t dotdot_get_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -384,7 +384,7 @@ uint8_t dotdot_get_basic_hw_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -396,7 +396,7 @@ sl_status_t dotdot_set_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_hw_version ++ int8_t new_hw_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -409,7 +409,7 @@ sl_status_t dotdot_set_basic_hw_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_hw_version, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_basic_hw_version_undefine_reported( +@@ -1153,7 +1153,7 @@ bool dotdot_is_supported_basic_product_code( + return attribute_store_node_exists(node); + } + +-const char* dotdot_get_basic_product_code( ++uint8_t dotdot_get_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -1176,7 +1176,7 @@ sl_status_t dotdot_set_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_product_code ++ uint8_t new_product_code + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2478,7 +2478,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_mains_voltage( ++int16_t dotdot_get_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2489,7 +2489,7 @@ uint16_t dotdot_get_power_configuration_mains_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2501,7 +2501,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage ++ int16_t new_mains_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2514,7 +2514,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_undefine_reported( +@@ -2589,7 +2589,7 @@ bool dotdot_is_supported_power_configuration_mains_frequency( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_mains_frequency( ++int8_t dotdot_get_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2600,7 +2600,7 @@ uint8_t dotdot_get_power_configuration_mains_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2612,7 +2612,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_mains_frequency ++ int8_t new_mains_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2625,7 +2625,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_frequency, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_mains_frequency_undefine_reported( +@@ -2811,7 +2811,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_mains_voltage_min_threshold( ++int16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2822,7 +2822,7 @@ uint16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2834,7 +2834,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_min_threshold ++ int16_t new_mains_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2847,7 +2847,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_min_threshold, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_min_threshold_undefine_reported( +@@ -2922,7 +2922,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_max_threshold( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_mains_voltage_max_threshold( ++int16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2933,7 +2933,7 @@ uint16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2945,7 +2945,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_max_threshold ++ int16_t new_mains_voltage_max_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2958,7 +2958,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_max_threshold, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_max_threshold_undefine_reported( +@@ -3033,7 +3033,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_dwell_trip_point( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( ++int16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3044,7 +3044,7 @@ uint16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3056,7 +3056,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mains_voltage_dwell_trip_point ++ int16_t new_mains_voltage_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3069,7 +3069,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_dwell_trip_point, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_dwell_trip_point_undefine_reported( +@@ -3144,7 +3144,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_voltage( ++int8_t dotdot_get_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3155,7 +3155,7 @@ uint8_t dotdot_get_power_configuration_battery_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3167,7 +3167,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage ++ int8_t new_battery_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3180,7 +3180,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_undefine_reported( +@@ -3255,7 +3255,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_remaining( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3266,7 +3266,7 @@ uint8_t dotdot_get_power_configuration_battery_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3278,7 +3278,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_remaining ++ int8_t new_battery_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3291,7 +3291,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_remaining, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_remaining_undefine_reported( +@@ -3589,7 +3589,7 @@ bool dotdot_is_supported_power_configuration_batterya_hr_rating( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_batterya_hr_rating( ++int16_t dotdot_get_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3600,7 +3600,7 @@ uint16_t dotdot_get_power_configuration_batterya_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3612,7 +3612,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_batterya_hr_rating ++ int16_t new_batterya_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3625,7 +3625,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_batterya_hr_rating, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_batterya_hr_rating_undefine_reported( +@@ -3700,7 +3700,7 @@ bool dotdot_is_supported_power_configuration_battery_quantity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_quantity( ++int8_t dotdot_get_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3711,7 +3711,7 @@ uint8_t dotdot_get_power_configuration_battery_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3723,7 +3723,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_quantity ++ int8_t new_battery_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3736,7 +3736,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_quantity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_quantity_undefine_reported( +@@ -3811,7 +3811,7 @@ bool dotdot_is_supported_power_configuration_battery_rated_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_rated_voltage( ++int8_t dotdot_get_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3822,7 +3822,7 @@ uint8_t dotdot_get_power_configuration_battery_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3834,7 +3834,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_rated_voltage ++ int8_t new_battery_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3847,7 +3847,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_rated_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_rated_voltage_undefine_reported( +@@ -4033,7 +4033,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4044,7 +4044,7 @@ uint8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4056,7 +4056,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_min_threshold ++ int8_t new_battery_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4069,7 +4069,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_min_threshold_undefine_reported( +@@ -4144,7 +4144,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4155,7 +4155,7 @@ uint8_t dotdot_get_power_configuration_battery_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4167,7 +4167,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold1 ++ int8_t new_battery_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4180,7 +4180,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold1_undefine_reported( +@@ -4255,7 +4255,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4266,7 +4266,7 @@ uint8_t dotdot_get_power_configuration_battery_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4278,7 +4278,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold2 ++ int8_t new_battery_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4291,7 +4291,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold2_undefine_reported( +@@ -4366,7 +4366,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4377,7 +4377,7 @@ uint8_t dotdot_get_power_configuration_battery_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4389,7 +4389,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_voltage_threshold3 ++ int8_t new_battery_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4402,7 +4402,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold3_undefine_reported( +@@ -4477,7 +4477,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4488,7 +4488,7 @@ uint8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4500,7 +4500,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_min_threshold ++ int8_t new_battery_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4513,7 +4513,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_min_threshold_undefine_reported( +@@ -4588,7 +4588,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4599,7 +4599,7 @@ uint8_t dotdot_get_power_configuration_battery_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4611,7 +4611,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold1 ++ int8_t new_battery_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4624,7 +4624,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold1_undefine_reported( +@@ -4699,7 +4699,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4710,7 +4710,7 @@ uint8_t dotdot_get_power_configuration_battery_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4722,7 +4722,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold2 ++ int8_t new_battery_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4735,7 +4735,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold2_undefine_reported( +@@ -4810,7 +4810,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4821,7 +4821,7 @@ uint8_t dotdot_get_power_configuration_battery_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4833,7 +4833,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery_percentage_threshold3 ++ int8_t new_battery_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4846,7 +4846,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold3_undefine_reported( +@@ -5032,7 +5032,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_voltage( ++int8_t dotdot_get_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5043,7 +5043,7 @@ uint8_t dotdot_get_power_configuration_battery2_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5055,7 +5055,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage ++ int8_t new_battery2_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5068,7 +5068,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_undefine_reported( +@@ -5143,7 +5143,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_remaining( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5154,7 +5154,7 @@ uint8_t dotdot_get_power_configuration_battery2_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5166,7 +5166,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_remaining ++ int8_t new_battery2_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5179,7 +5179,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_remaining, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_remaining_undefine_reported( +@@ -5477,7 +5477,7 @@ bool dotdot_is_supported_power_configuration_battery2a_hr_rating( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_battery2a_hr_rating( ++int16_t dotdot_get_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5488,7 +5488,7 @@ uint16_t dotdot_get_power_configuration_battery2a_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5500,7 +5500,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_battery2a_hr_rating ++ int16_t new_battery2a_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5513,7 +5513,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2a_hr_rating, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_battery2a_hr_rating_undefine_reported( +@@ -5588,7 +5588,7 @@ bool dotdot_is_supported_power_configuration_battery2_quantity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_quantity( ++int8_t dotdot_get_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5599,7 +5599,7 @@ uint8_t dotdot_get_power_configuration_battery2_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5611,7 +5611,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_quantity ++ int8_t new_battery2_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5624,7 +5624,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_quantity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_quantity_undefine_reported( +@@ -5699,7 +5699,7 @@ bool dotdot_is_supported_power_configuration_battery2_rated_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_rated_voltage( ++int8_t dotdot_get_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5710,7 +5710,7 @@ uint8_t dotdot_get_power_configuration_battery2_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5722,7 +5722,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_rated_voltage ++ int8_t new_battery2_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5735,7 +5735,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_rated_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_rated_voltage_undefine_reported( +@@ -5921,7 +5921,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5932,7 +5932,7 @@ uint8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5944,7 +5944,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_min_threshold ++ int8_t new_battery2_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5957,7 +5957,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_min_threshold_undefine_reported( +@@ -6032,7 +6032,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6043,7 +6043,7 @@ uint8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6055,7 +6055,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold1 ++ int8_t new_battery2_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6068,7 +6068,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold1_undefine_reported( +@@ -6143,7 +6143,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6154,7 +6154,7 @@ uint8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6166,7 +6166,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold2 ++ int8_t new_battery2_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6179,7 +6179,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold2_undefine_reported( +@@ -6254,7 +6254,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6265,7 +6265,7 @@ uint8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6277,7 +6277,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_voltage_threshold3 ++ int8_t new_battery2_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6290,7 +6290,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold3_undefine_reported( +@@ -6365,7 +6365,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6376,7 +6376,7 @@ uint8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6388,7 +6388,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_min_threshold ++ int8_t new_battery2_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6401,7 +6401,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_min_threshold_undefine_reported( +@@ -6476,7 +6476,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6487,7 +6487,7 @@ uint8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6499,7 +6499,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold1 ++ int8_t new_battery2_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6512,7 +6512,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold1_undefine_reported( +@@ -6587,7 +6587,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6598,7 +6598,7 @@ uint8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6610,7 +6610,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold2 ++ int8_t new_battery2_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6623,7 +6623,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold2_undefine_reported( +@@ -6698,7 +6698,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery2_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6709,7 +6709,7 @@ uint8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6721,7 +6721,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery2_percentage_threshold3 ++ int8_t new_battery2_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6734,7 +6734,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold3_undefine_reported( +@@ -6920,7 +6920,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_voltage( ++int8_t dotdot_get_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6931,7 +6931,7 @@ uint8_t dotdot_get_power_configuration_battery3_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6943,7 +6943,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage ++ int8_t new_battery3_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6956,7 +6956,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_undefine_reported( +@@ -7031,7 +7031,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_remaining( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_percentage_remaining( ++int8_t dotdot_get_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7042,7 +7042,7 @@ uint8_t dotdot_get_power_configuration_battery3_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7054,7 +7054,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_remaining ++ int8_t new_battery3_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7067,7 +7067,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_remaining, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_remaining_undefine_reported( +@@ -7365,7 +7365,7 @@ bool dotdot_is_supported_power_configuration_battery3a_hr_rating( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_power_configuration_battery3a_hr_rating( ++int16_t dotdot_get_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7376,7 +7376,7 @@ uint16_t dotdot_get_power_configuration_battery3a_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7388,7 +7388,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_battery3a_hr_rating ++ int16_t new_battery3a_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7401,7 +7401,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3a_hr_rating, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_power_configuration_battery3a_hr_rating_undefine_reported( +@@ -7476,7 +7476,7 @@ bool dotdot_is_supported_power_configuration_battery3_quantity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_quantity( ++int8_t dotdot_get_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7487,7 +7487,7 @@ uint8_t dotdot_get_power_configuration_battery3_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7499,7 +7499,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_quantity ++ int8_t new_battery3_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7512,7 +7512,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_quantity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_quantity_undefine_reported( +@@ -7587,7 +7587,7 @@ bool dotdot_is_supported_power_configuration_battery3_rated_voltage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_rated_voltage( ++int8_t dotdot_get_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7598,7 +7598,7 @@ uint8_t dotdot_get_power_configuration_battery3_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7610,7 +7610,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_rated_voltage ++ int8_t new_battery3_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7623,7 +7623,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_rated_voltage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_rated_voltage_undefine_reported( +@@ -7809,7 +7809,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( ++int8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7820,7 +7820,7 @@ uint8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7832,7 +7832,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_min_threshold ++ int8_t new_battery3_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7845,7 +7845,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_min_threshold_undefine_reported( +@@ -7920,7 +7920,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold1( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7931,7 +7931,7 @@ uint8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7943,7 +7943,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold1 ++ int8_t new_battery3_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7956,7 +7956,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold1_undefine_reported( +@@ -8031,7 +8031,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold2( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8042,7 +8042,7 @@ uint8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8054,7 +8054,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold2 ++ int8_t new_battery3_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8067,7 +8067,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold2_undefine_reported( +@@ -8142,7 +8142,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_voltage_threshold3( ++int8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8153,7 +8153,7 @@ uint8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8165,7 +8165,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_voltage_threshold3 ++ int8_t new_battery3_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8178,7 +8178,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold3_undefine_reported( +@@ -8253,7 +8253,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( ++int8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8264,7 +8264,7 @@ uint8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8276,7 +8276,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_min_threshold ++ int8_t new_battery3_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8289,7 +8289,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_min_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_min_threshold_undefine_reported( +@@ -8364,7 +8364,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold1( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8375,7 +8375,7 @@ uint8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8387,7 +8387,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold1 ++ int8_t new_battery3_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8400,7 +8400,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold1, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold1_undefine_reported( +@@ -8475,7 +8475,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold2( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8486,7 +8486,7 @@ uint8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8498,7 +8498,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold2 ++ int8_t new_battery3_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8511,7 +8511,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold2, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold2_undefine_reported( +@@ -8586,7 +8586,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_power_configuration_battery3_percentage_threshold3( ++int8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8597,7 +8597,7 @@ uint8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8609,7 +8609,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_battery3_percentage_threshold3 ++ int8_t new_battery3_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8622,7 +8622,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold3, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold3_undefine_reported( +@@ -9469,7 +9469,7 @@ bool dotdot_is_supported_device_temperature_configuration_over_temp_total_dwell( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( ++int16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -9480,7 +9480,7 @@ uint16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -9492,7 +9492,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_over_temp_total_dwell ++ int16_t new_over_temp_total_dwell + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -9505,7 +9505,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_over_temp_total_dwell, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_device_temperature_configuration_over_temp_total_dwell_undefine_reported( +@@ -9913,7 +9913,7 @@ bool dotdot_is_supported_device_temperature_configuration_low_temp_dwell_trip_po + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( ++int32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -9924,7 +9924,7 @@ uint32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -9936,7 +9936,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_low_temp_dwell_trip_point ++ int32_t new_low_temp_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -9949,7 +9949,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_low_temp_dwell_trip_point, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_device_temperature_configuration_low_temp_dwell_trip_point_undefine_reported( +@@ -10024,7 +10024,7 @@ bool dotdot_is_supported_device_temperature_configuration_high_temp_dwell_trip_p + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( ++int32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10035,7 +10035,7 @@ uint32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10047,7 +10047,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_high_temp_dwell_trip_point ++ int32_t new_high_temp_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10060,7 +10060,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_high_temp_dwell_trip_point, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_device_temperature_configuration_high_temp_dwell_trip_point_undefine_reported( +@@ -10196,7 +10196,7 @@ bool dotdot_is_supported_identify_identify_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_identify_identify_time( ++int16_t dotdot_get_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10207,7 +10207,7 @@ uint16_t dotdot_get_identify_identify_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10219,7 +10219,7 @@ sl_status_t dotdot_set_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_identify_time ++ int16_t new_identify_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10232,7 +10232,7 @@ sl_status_t dotdot_set_identify_identify_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_identify_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_identify_identify_time_undefine_reported( +@@ -10465,7 +10465,7 @@ bool dotdot_is_supported_scenes_scene_count( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_scenes_scene_count( ++int8_t dotdot_get_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10476,7 +10476,7 @@ uint8_t dotdot_get_scenes_scene_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10488,7 +10488,7 @@ sl_status_t dotdot_set_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_scene_count ++ int8_t new_scene_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10501,7 +10501,7 @@ sl_status_t dotdot_set_scenes_scene_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_scene_count, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_scenes_scene_count_undefine_reported( +@@ -10576,7 +10576,7 @@ bool dotdot_is_supported_scenes_current_scene( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_scenes_current_scene( ++int8_t dotdot_get_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10587,7 +10587,7 @@ uint8_t dotdot_get_scenes_current_scene( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10599,7 +10599,7 @@ sl_status_t dotdot_set_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_scene ++ int8_t new_current_scene + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10612,7 +10612,7 @@ sl_status_t dotdot_set_scenes_current_scene( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_scene, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_scenes_current_scene_undefine_reported( +@@ -10687,7 +10687,7 @@ bool dotdot_is_supported_scenes_current_group( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_scenes_current_group( ++uint8_t * dotdot_get_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10698,7 +10698,7 @@ uint16_t dotdot_get_scenes_current_group( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP); + +- uint16_t result = {}; ++ uint8_t * result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10710,7 +10710,7 @@ sl_status_t dotdot_set_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_group ++ uint8_t * new_current_group + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10723,7 +10723,7 @@ sl_status_t dotdot_set_scenes_current_group( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_group, +- sizeof(uint16_t)); ++ sizeof(uint8_t *)); + } + + sl_status_t dotdot_scenes_current_group_undefine_reported( +@@ -11507,7 +11507,7 @@ bool dotdot_is_supported_on_off_on_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_on_off_on_time( ++int16_t dotdot_get_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11518,7 +11518,7 @@ uint16_t dotdot_get_on_off_on_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11530,7 +11530,7 @@ sl_status_t dotdot_set_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_time ++ int16_t new_on_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11543,7 +11543,7 @@ sl_status_t dotdot_set_on_off_on_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_on_off_on_time_undefine_reported( +@@ -11618,7 +11618,7 @@ bool dotdot_is_supported_on_off_off_wait_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_on_off_off_wait_time( ++int16_t dotdot_get_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11629,7 +11629,7 @@ uint16_t dotdot_get_on_off_off_wait_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11641,7 +11641,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_off_wait_time ++ int16_t new_off_wait_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11654,7 +11654,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_off_wait_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_on_off_off_wait_time_undefine_reported( +@@ -11883,7 +11883,7 @@ bool dotdot_is_supported_level_current_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_level_current_level( ++int8_t dotdot_get_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11894,7 +11894,7 @@ uint8_t dotdot_get_level_current_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11906,7 +11906,7 @@ sl_status_t dotdot_set_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_level ++ int8_t new_current_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11919,7 +11919,7 @@ sl_status_t dotdot_set_level_current_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_level_current_level_undefine_reported( +@@ -11994,7 +11994,7 @@ bool dotdot_is_supported_level_remaining_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_remaining_time( ++int16_t dotdot_get_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12005,7 +12005,7 @@ uint16_t dotdot_get_level_remaining_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12017,7 +12017,7 @@ sl_status_t dotdot_set_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_remaining_time ++ int16_t new_remaining_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12030,7 +12030,7 @@ sl_status_t dotdot_set_level_remaining_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_remaining_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_remaining_time_undefine_reported( +@@ -12105,7 +12105,7 @@ bool dotdot_is_supported_level_min_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_level_min_level( ++int8_t dotdot_get_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12116,7 +12116,7 @@ uint8_t dotdot_get_level_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12128,7 +12128,7 @@ sl_status_t dotdot_set_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_level ++ int8_t new_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12141,7 +12141,7 @@ sl_status_t dotdot_set_level_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_level_min_level_undefine_reported( +@@ -12216,7 +12216,7 @@ bool dotdot_is_supported_level_max_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_level_max_level( ++int8_t dotdot_get_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12227,7 +12227,7 @@ uint8_t dotdot_get_level_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12239,7 +12239,7 @@ sl_status_t dotdot_set_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_level ++ int8_t new_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12252,7 +12252,7 @@ sl_status_t dotdot_set_level_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_level_max_level_undefine_reported( +@@ -12327,7 +12327,7 @@ bool dotdot_is_supported_level_current_frequency( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_current_frequency( ++int16_t dotdot_get_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12338,7 +12338,7 @@ uint16_t dotdot_get_level_current_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12350,7 +12350,7 @@ sl_status_t dotdot_set_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_frequency ++ int16_t new_current_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12363,7 +12363,7 @@ sl_status_t dotdot_set_level_current_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_frequency, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_current_frequency_undefine_reported( +@@ -12438,7 +12438,7 @@ bool dotdot_is_supported_level_min_frequency( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_min_frequency( ++int16_t dotdot_get_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12449,7 +12449,7 @@ uint16_t dotdot_get_level_min_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12461,7 +12461,7 @@ sl_status_t dotdot_set_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_frequency ++ int16_t new_min_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12474,7 +12474,7 @@ sl_status_t dotdot_set_level_min_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_frequency, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_min_frequency_undefine_reported( +@@ -12549,7 +12549,7 @@ bool dotdot_is_supported_level_max_frequency( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_max_frequency( ++int16_t dotdot_get_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12560,7 +12560,7 @@ uint16_t dotdot_get_level_max_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12572,7 +12572,7 @@ sl_status_t dotdot_set_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_frequency ++ int16_t new_max_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12585,7 +12585,7 @@ sl_status_t dotdot_set_level_max_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_frequency, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_max_frequency_undefine_reported( +@@ -12771,7 +12771,7 @@ bool dotdot_is_supported_level_on_off_transition_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_on_off_transition_time( ++int16_t dotdot_get_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12782,7 +12782,7 @@ uint16_t dotdot_get_level_on_off_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12794,7 +12794,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_off_transition_time ++ int16_t new_on_off_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12807,7 +12807,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_off_transition_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_on_off_transition_time_undefine_reported( +@@ -12882,7 +12882,7 @@ bool dotdot_is_supported_level_on_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_level_on_level( ++int8_t dotdot_get_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12893,7 +12893,7 @@ uint8_t dotdot_get_level_on_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12905,7 +12905,7 @@ sl_status_t dotdot_set_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_on_level ++ int8_t new_on_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12918,7 +12918,7 @@ sl_status_t dotdot_set_level_on_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_level_on_level_undefine_reported( +@@ -12993,7 +12993,7 @@ bool dotdot_is_supported_level_on_transition_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_on_transition_time( ++int16_t dotdot_get_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13004,7 +13004,7 @@ uint16_t dotdot_get_level_on_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13016,7 +13016,7 @@ sl_status_t dotdot_set_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_on_transition_time ++ int16_t new_on_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13029,7 +13029,7 @@ sl_status_t dotdot_set_level_on_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_transition_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_on_transition_time_undefine_reported( +@@ -13104,7 +13104,7 @@ bool dotdot_is_supported_level_off_transition_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_off_transition_time( ++int16_t dotdot_get_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13115,7 +13115,7 @@ uint16_t dotdot_get_level_off_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13127,7 +13127,7 @@ sl_status_t dotdot_set_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_off_transition_time ++ int16_t new_off_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13140,7 +13140,7 @@ sl_status_t dotdot_set_level_off_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_off_transition_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_off_transition_time_undefine_reported( +@@ -13215,7 +13215,7 @@ bool dotdot_is_supported_level_default_move_rate( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_level_default_move_rate( ++int16_t dotdot_get_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13226,7 +13226,7 @@ uint16_t dotdot_get_level_default_move_rate( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13238,7 +13238,7 @@ sl_status_t dotdot_set_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_default_move_rate ++ int16_t new_default_move_rate + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13251,7 +13251,7 @@ sl_status_t dotdot_set_level_default_move_rate( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_default_move_rate, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_level_default_move_rate_undefine_reported( +@@ -13326,7 +13326,7 @@ bool dotdot_is_supported_level_start_up_current_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_level_start_up_current_level( ++int8_t dotdot_get_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13337,7 +13337,7 @@ uint8_t dotdot_get_level_start_up_current_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13349,7 +13349,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_start_up_current_level ++ int8_t new_start_up_current_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13362,7 +13362,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_start_up_current_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_level_start_up_current_level_undefine_reported( +@@ -13519,7 +13519,7 @@ bool dotdot_is_supported_alarms_alarm_count( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_alarms_alarm_count( ++int16_t dotdot_get_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13530,7 +13530,7 @@ uint16_t dotdot_get_alarms_alarm_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13542,7 +13542,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_alarm_count ++ int16_t new_alarm_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13555,7 +13555,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_alarm_count, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_alarms_alarm_count_undefine_reported( +@@ -13652,7 +13652,7 @@ bool dotdot_is_supported_time_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_time( ++uint8_t dotdot_get_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13663,7 +13663,7 @@ uint32_t dotdot_get_time_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13675,7 +13675,7 @@ sl_status_t dotdot_set_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_time ++ uint8_t new_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13688,7 +13688,7 @@ sl_status_t dotdot_set_time_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_time_time_undefine_reported( +@@ -13985,7 +13985,7 @@ bool dotdot_is_supported_time_dst_start( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_dst_start( ++int32_t dotdot_get_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13996,7 +13996,7 @@ uint32_t dotdot_get_time_dst_start( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_DST_START); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14008,7 +14008,7 @@ sl_status_t dotdot_set_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_dst_start ++ int32_t new_dst_start + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14021,7 +14021,7 @@ sl_status_t dotdot_set_time_dst_start( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dst_start, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_time_dst_start_undefine_reported( +@@ -14096,7 +14096,7 @@ bool dotdot_is_supported_time_dst_end( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_dst_end( ++int32_t dotdot_get_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14107,7 +14107,7 @@ uint32_t dotdot_get_time_dst_end( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_DST_END); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14119,7 +14119,7 @@ sl_status_t dotdot_set_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_dst_end ++ int32_t new_dst_end + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14132,7 +14132,7 @@ sl_status_t dotdot_set_time_dst_end( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dst_end, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_time_dst_end_undefine_reported( +@@ -14318,7 +14318,7 @@ bool dotdot_is_supported_time_standard_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_standard_time( ++int32_t dotdot_get_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14329,7 +14329,7 @@ uint32_t dotdot_get_time_standard_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14341,7 +14341,7 @@ sl_status_t dotdot_set_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_standard_time ++ int32_t new_standard_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14354,7 +14354,7 @@ sl_status_t dotdot_set_time_standard_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_standard_time, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_time_standard_time_undefine_reported( +@@ -14429,7 +14429,7 @@ bool dotdot_is_supported_time_local_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_local_time( ++int32_t dotdot_get_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14440,7 +14440,7 @@ uint32_t dotdot_get_time_local_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14452,7 +14452,7 @@ sl_status_t dotdot_set_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_local_time ++ int32_t new_local_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14465,7 +14465,7 @@ sl_status_t dotdot_set_time_local_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_local_time, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_time_local_time_undefine_reported( +@@ -14540,7 +14540,7 @@ bool dotdot_is_supported_time_last_set_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_last_set_time( ++uint8_t dotdot_get_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14551,7 +14551,7 @@ uint32_t dotdot_get_time_last_set_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14563,7 +14563,7 @@ sl_status_t dotdot_set_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_last_set_time ++ uint8_t new_last_set_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14576,7 +14576,7 @@ sl_status_t dotdot_set_time_last_set_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_last_set_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_time_last_set_time_undefine_reported( +@@ -14651,7 +14651,7 @@ bool dotdot_is_supported_time_valid_until_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_time_valid_until_time( ++uint8_t dotdot_get_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14662,7 +14662,7 @@ uint32_t dotdot_get_time_valid_until_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14674,7 +14674,7 @@ sl_status_t dotdot_set_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_valid_until_time ++ uint8_t new_valid_until_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14687,7 +14687,7 @@ sl_status_t dotdot_set_time_valid_until_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_valid_until_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_time_valid_until_time_undefine_reported( +@@ -14832,7 +14832,7 @@ bool dotdot_is_supported_poll_control_check_in_interval( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_poll_control_check_in_interval( ++int32_t dotdot_get_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14843,7 +14843,7 @@ uint32_t dotdot_get_poll_control_check_in_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14855,7 +14855,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_check_in_interval ++ int32_t new_check_in_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14868,7 +14868,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_check_in_interval, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_poll_control_check_in_interval_undefine_reported( +@@ -14943,7 +14943,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_poll_control_long_poll_interval( ++int32_t dotdot_get_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14954,7 +14954,7 @@ uint32_t dotdot_get_poll_control_long_poll_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14966,7 +14966,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_long_poll_interval ++ int32_t new_long_poll_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14979,7 +14979,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_long_poll_interval, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_poll_control_long_poll_interval_undefine_reported( +@@ -15054,7 +15054,7 @@ bool dotdot_is_supported_poll_control_short_poll_interval( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_poll_control_short_poll_interval( ++int16_t dotdot_get_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15065,7 +15065,7 @@ uint16_t dotdot_get_poll_control_short_poll_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15077,7 +15077,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_short_poll_interval ++ int16_t new_short_poll_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15090,7 +15090,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_short_poll_interval, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_poll_control_short_poll_interval_undefine_reported( +@@ -15165,7 +15165,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_poll_control_fast_poll_timeout( ++int16_t dotdot_get_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15176,7 +15176,7 @@ uint16_t dotdot_get_poll_control_fast_poll_timeout( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15188,7 +15188,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_fast_poll_timeout ++ int16_t new_fast_poll_timeout + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15201,7 +15201,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_fast_poll_timeout, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_poll_control_fast_poll_timeout_undefine_reported( +@@ -15276,7 +15276,7 @@ bool dotdot_is_supported_poll_control_check_in_interval_min( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_poll_control_check_in_interval_min( ++int32_t dotdot_get_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15287,7 +15287,7 @@ uint32_t dotdot_get_poll_control_check_in_interval_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15299,7 +15299,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_check_in_interval_min ++ int32_t new_check_in_interval_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15312,7 +15312,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_check_in_interval_min, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_poll_control_check_in_interval_min_undefine_reported( +@@ -15387,7 +15387,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval_min( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_poll_control_long_poll_interval_min( ++int32_t dotdot_get_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15398,7 +15398,7 @@ uint32_t dotdot_get_poll_control_long_poll_interval_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15410,7 +15410,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_long_poll_interval_min ++ int32_t new_long_poll_interval_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15423,7 +15423,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_long_poll_interval_min, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_poll_control_long_poll_interval_min_undefine_reported( +@@ -15498,7 +15498,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout_max( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_poll_control_fast_poll_timeout_max( ++int16_t dotdot_get_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15509,7 +15509,7 @@ uint16_t dotdot_get_poll_control_fast_poll_timeout_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15521,7 +15521,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_fast_poll_timeout_max ++ int16_t new_fast_poll_timeout_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15534,7 +15534,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_fast_poll_timeout_max, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_poll_control_fast_poll_timeout_max_undefine_reported( +@@ -15655,7 +15655,7 @@ bool dotdot_is_supported_shade_configuration_physical_closed_limit( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_shade_configuration_physical_closed_limit( ++int16_t dotdot_get_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15666,7 +15666,7 @@ uint16_t dotdot_get_shade_configuration_physical_closed_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15678,7 +15678,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit ++ int16_t new_physical_closed_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15691,7 +15691,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_shade_configuration_physical_closed_limit_undefine_reported( +@@ -15766,7 +15766,7 @@ bool dotdot_is_supported_shade_configuration_motor_step_size( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_shade_configuration_motor_step_size( ++int8_t dotdot_get_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15777,7 +15777,7 @@ uint8_t dotdot_get_shade_configuration_motor_step_size( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15789,7 +15789,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_motor_step_size ++ int8_t new_motor_step_size + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15802,7 +15802,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_motor_step_size, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_shade_configuration_motor_step_size_undefine_reported( +@@ -15988,7 +15988,7 @@ bool dotdot_is_supported_shade_configuration_closed_limit( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_shade_configuration_closed_limit( ++int16_t dotdot_get_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15999,7 +15999,7 @@ uint16_t dotdot_get_shade_configuration_closed_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16011,7 +16011,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_closed_limit ++ int16_t new_closed_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16024,7 +16024,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_closed_limit, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_shade_configuration_closed_limit_undefine_reported( +@@ -16697,7 +16697,7 @@ bool dotdot_is_supported_door_lock_door_open_events( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_door_lock_door_open_events( ++int32_t dotdot_get_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16708,7 +16708,7 @@ uint32_t dotdot_get_door_lock_door_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16720,7 +16720,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_door_open_events ++ int32_t new_door_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16733,7 +16733,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_door_open_events, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_door_lock_door_open_events_undefine_reported( +@@ -16808,7 +16808,7 @@ bool dotdot_is_supported_door_lock_door_closed_events( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_door_lock_door_closed_events( ++int32_t dotdot_get_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16819,7 +16819,7 @@ uint32_t dotdot_get_door_lock_door_closed_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16831,7 +16831,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_door_closed_events ++ int32_t new_door_closed_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16844,7 +16844,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_door_closed_events, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_door_lock_door_closed_events_undefine_reported( +@@ -16919,7 +16919,7 @@ bool dotdot_is_supported_door_lock_open_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_open_period( ++int16_t dotdot_get_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16930,7 +16930,7 @@ uint16_t dotdot_get_door_lock_open_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16942,7 +16942,7 @@ sl_status_t dotdot_set_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_period ++ int16_t new_open_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16955,7 +16955,7 @@ sl_status_t dotdot_set_door_lock_open_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_open_period_undefine_reported( +@@ -17030,7 +17030,7 @@ bool dotdot_is_supported_door_lock_number_of_log_records_supported( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_number_of_log_records_supported( ++int16_t dotdot_get_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17041,7 +17041,7 @@ uint16_t dotdot_get_door_lock_number_of_log_records_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17053,7 +17053,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_log_records_supported ++ int16_t new_number_of_log_records_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17066,7 +17066,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_log_records_supported, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_number_of_log_records_supported_undefine_reported( +@@ -17141,7 +17141,7 @@ bool dotdot_is_supported_door_lock_number_of_total_users_supported( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_number_of_total_users_supported( ++int16_t dotdot_get_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17152,7 +17152,7 @@ uint16_t dotdot_get_door_lock_number_of_total_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17164,7 +17164,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_total_users_supported ++ int16_t new_number_of_total_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17177,7 +17177,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_total_users_supported, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_number_of_total_users_supported_undefine_reported( +@@ -17252,7 +17252,7 @@ bool dotdot_is_supported_door_lock_number_of_pin_users_supported( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_number_of_pin_users_supported( ++int16_t dotdot_get_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17263,7 +17263,7 @@ uint16_t dotdot_get_door_lock_number_of_pin_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17275,7 +17275,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_pin_users_supported ++ int16_t new_number_of_pin_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17288,7 +17288,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_pin_users_supported, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_number_of_pin_users_supported_undefine_reported( +@@ -17363,7 +17363,7 @@ bool dotdot_is_supported_door_lock_number_of_rfid_users_supported( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_number_of_rfid_users_supported( ++int16_t dotdot_get_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17374,7 +17374,7 @@ uint16_t dotdot_get_door_lock_number_of_rfid_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17386,7 +17386,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_rfid_users_supported ++ int16_t new_number_of_rfid_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17399,7 +17399,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_rfid_users_supported, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_number_of_rfid_users_supported_undefine_reported( +@@ -17474,7 +17474,7 @@ bool dotdot_is_supported_door_lock_number_of_week_day_schedules_supported_per_us + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17485,7 +17485,7 @@ uint8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17497,7 +17497,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_week_day_schedules_supported_per_user ++ int8_t new_number_of_week_day_schedules_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17510,7 +17510,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_week_day_schedules_supported_per_user, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_number_of_week_day_schedules_supported_per_user_undefine_reported( +@@ -17585,7 +17585,7 @@ bool dotdot_is_supported_door_lock_number_of_year_day_schedules_supported_per_us + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17596,7 +17596,7 @@ uint8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17608,7 +17608,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_year_day_schedules_supported_per_user ++ int8_t new_number_of_year_day_schedules_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17621,7 +17621,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_year_day_schedules_supported_per_user, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_number_of_year_day_schedules_supported_per_user_undefine_reported( +@@ -17696,7 +17696,7 @@ bool dotdot_is_supported_door_lock_number_of_holiday_schedules_supported( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( ++int8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17707,7 +17707,7 @@ uint8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17719,7 +17719,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_holiday_schedules_supported ++ int8_t new_number_of_holiday_schedules_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17732,7 +17732,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_holiday_schedules_supported, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_number_of_holiday_schedules_supported_undefine_reported( +@@ -17807,7 +17807,7 @@ bool dotdot_is_supported_door_lock_max_pin_code_length( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_max_pin_code_length( ++int8_t dotdot_get_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17818,7 +17818,7 @@ uint8_t dotdot_get_door_lock_max_pin_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17830,7 +17830,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_pin_code_length ++ int8_t new_max_pin_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17843,7 +17843,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_pin_code_length, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_max_pin_code_length_undefine_reported( +@@ -17918,7 +17918,7 @@ bool dotdot_is_supported_door_lock_min_pin_code_length( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_min_pin_code_length( ++int8_t dotdot_get_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17929,7 +17929,7 @@ uint8_t dotdot_get_door_lock_min_pin_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17941,7 +17941,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_pin_code_length ++ int8_t new_min_pin_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17954,7 +17954,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_pin_code_length, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_min_pin_code_length_undefine_reported( +@@ -18029,7 +18029,7 @@ bool dotdot_is_supported_door_lock_max_rfid_code_length( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_max_rfid_code_length( ++int8_t dotdot_get_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18040,7 +18040,7 @@ uint8_t dotdot_get_door_lock_max_rfid_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18052,7 +18052,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_rfid_code_length ++ int8_t new_max_rfid_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18065,7 +18065,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_rfid_code_length, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_max_rfid_code_length_undefine_reported( +@@ -18140,7 +18140,7 @@ bool dotdot_is_supported_door_lock_min_rfid_code_length( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_min_rfid_code_length( ++int8_t dotdot_get_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18151,7 +18151,7 @@ uint8_t dotdot_get_door_lock_min_rfid_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18163,7 +18163,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_rfid_code_length ++ int8_t new_min_rfid_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18176,7 +18176,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_rfid_code_length, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_min_rfid_code_length_undefine_reported( +@@ -18362,7 +18362,7 @@ bool dotdot_is_supported_door_lock_number_of_credentials_supported_per_user( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( ++int8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18373,7 +18373,7 @@ uint8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18385,7 +18385,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_credentials_supported_per_user ++ int8_t new_number_of_credentials_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18398,7 +18398,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_credentials_supported_per_user, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_number_of_credentials_supported_per_user_undefine_reported( +@@ -18696,7 +18696,7 @@ bool dotdot_is_supported_door_lock_led_settings( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_led_settings( ++int8_t dotdot_get_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18707,7 +18707,7 @@ uint8_t dotdot_get_door_lock_led_settings( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18719,7 +18719,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_led_settings ++ int8_t new_led_settings + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18732,7 +18732,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_led_settings, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_led_settings_undefine_reported( +@@ -18807,7 +18807,7 @@ bool dotdot_is_supported_door_lock_auto_relock_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_door_lock_auto_relock_time( ++int32_t dotdot_get_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18818,7 +18818,7 @@ uint32_t dotdot_get_door_lock_auto_relock_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18830,7 +18830,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_auto_relock_time ++ int32_t new_auto_relock_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18843,7 +18843,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_auto_relock_time, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_door_lock_auto_relock_time_undefine_reported( +@@ -18918,7 +18918,7 @@ bool dotdot_is_supported_door_lock_sound_volume( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_sound_volume( ++int8_t dotdot_get_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18929,7 +18929,7 @@ uint8_t dotdot_get_door_lock_sound_volume( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18941,7 +18941,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_sound_volume ++ int8_t new_sound_volume + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18954,7 +18954,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_sound_volume, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_sound_volume_undefine_reported( +@@ -19917,7 +19917,7 @@ bool dotdot_is_supported_door_lock_wrong_code_entry_limit( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_wrong_code_entry_limit( ++int8_t dotdot_get_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -19928,7 +19928,7 @@ uint8_t dotdot_get_door_lock_wrong_code_entry_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -19940,7 +19940,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_wrong_code_entry_limit ++ int8_t new_wrong_code_entry_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -19953,7 +19953,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_wrong_code_entry_limit, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_wrong_code_entry_limit_undefine_reported( +@@ -20028,7 +20028,7 @@ bool dotdot_is_supported_door_lock_user_code_temporary_disable_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_door_lock_user_code_temporary_disable_time( ++int8_t dotdot_get_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -20039,7 +20039,7 @@ uint8_t dotdot_get_door_lock_user_code_temporary_disable_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -20051,7 +20051,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_user_code_temporary_disable_time ++ int8_t new_user_code_temporary_disable_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -20064,7 +20064,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_user_code_temporary_disable_time, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_door_lock_user_code_temporary_disable_time_undefine_reported( +@@ -20472,7 +20472,7 @@ bool dotdot_is_supported_door_lock_expiring_user_timeout( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_door_lock_expiring_user_timeout( ++int16_t dotdot_get_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -20483,7 +20483,7 @@ uint16_t dotdot_get_door_lock_expiring_user_timeout( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -20495,7 +20495,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_expiring_user_timeout ++ int16_t new_expiring_user_timeout + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -20508,7 +20508,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_expiring_user_timeout, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_door_lock_expiring_user_timeout_undefine_reported( +@@ -21937,7 +21937,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_physical_closed_limit_lift( ++int16_t dotdot_get_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -21948,7 +21948,7 @@ uint16_t dotdot_get_window_covering_physical_closed_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -21960,7 +21960,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit_lift ++ int16_t new_physical_closed_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -21973,7 +21973,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_physical_closed_limit_lift_undefine_reported( +@@ -22048,7 +22048,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_tilt( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_physical_closed_limit_tilt( ++int16_t dotdot_get_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22059,7 +22059,7 @@ uint16_t dotdot_get_window_covering_physical_closed_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22071,7 +22071,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_closed_limit_tilt ++ int16_t new_physical_closed_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22084,7 +22084,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit_tilt, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_physical_closed_limit_tilt_undefine_reported( +@@ -22159,7 +22159,7 @@ bool dotdot_is_supported_window_covering_current_position_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_current_position_lift( ++int16_t dotdot_get_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22170,7 +22170,7 @@ uint16_t dotdot_get_window_covering_current_position_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22182,7 +22182,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_position_lift ++ int16_t new_current_position_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22195,7 +22195,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_current_position_lift_undefine_reported( +@@ -22270,7 +22270,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_current_position_tilt( ++int16_t dotdot_get_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22281,7 +22281,7 @@ uint16_t dotdot_get_window_covering_current_position_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22293,7 +22293,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_current_position_tilt ++ int16_t new_current_position_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22306,7 +22306,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_tilt, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_current_position_tilt_undefine_reported( +@@ -22381,7 +22381,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_number_of_actuations_lift( ++int16_t dotdot_get_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22392,7 +22392,7 @@ uint16_t dotdot_get_window_covering_number_of_actuations_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22404,7 +22404,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_actuations_lift ++ int16_t new_number_of_actuations_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22417,7 +22417,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_actuations_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_number_of_actuations_lift_undefine_reported( +@@ -22492,7 +22492,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_tilt( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_number_of_actuations_tilt( ++int16_t dotdot_get_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22503,7 +22503,7 @@ uint16_t dotdot_get_window_covering_number_of_actuations_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22515,7 +22515,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_actuations_tilt ++ int16_t new_number_of_actuations_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22528,7 +22528,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_actuations_tilt, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_number_of_actuations_tilt_undefine_reported( +@@ -22714,7 +22714,7 @@ bool dotdot_is_supported_window_covering_current_position_lift_percentage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_window_covering_current_position_lift_percentage( ++int8_t dotdot_get_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22725,7 +22725,7 @@ uint8_t dotdot_get_window_covering_current_position_lift_percentage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22737,7 +22737,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_position_lift_percentage ++ int8_t new_current_position_lift_percentage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22750,7 +22750,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_lift_percentage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_window_covering_current_position_lift_percentage_undefine_reported( +@@ -22825,7 +22825,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt_percentage( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_window_covering_current_position_tilt_percentage( ++int8_t dotdot_get_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22836,7 +22836,7 @@ uint8_t dotdot_get_window_covering_current_position_tilt_percentage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22848,7 +22848,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_position_tilt_percentage ++ int8_t new_current_position_tilt_percentage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22861,7 +22861,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_tilt_percentage, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_window_covering_current_position_tilt_percentage_undefine_reported( +@@ -22936,7 +22936,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_installed_open_limit_lift( ++int16_t dotdot_get_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22947,7 +22947,7 @@ uint16_t dotdot_get_window_covering_installed_open_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22959,7 +22959,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_open_limit_lift ++ int16_t new_installed_open_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22972,7 +22972,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_open_limit_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_installed_open_limit_lift_undefine_reported( +@@ -23047,7 +23047,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_installed_closed_limit_lift( ++int16_t dotdot_get_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23058,7 +23058,7 @@ uint16_t dotdot_get_window_covering_installed_closed_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23070,7 +23070,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_closed_limit_lift ++ int16_t new_installed_closed_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23083,7 +23083,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_closed_limit_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_installed_closed_limit_lift_undefine_reported( +@@ -23158,7 +23158,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_tilt( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_installed_open_limit_tilt( ++int16_t dotdot_get_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23169,7 +23169,7 @@ uint16_t dotdot_get_window_covering_installed_open_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23181,7 +23181,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_open_limit_tilt ++ int16_t new_installed_open_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23194,7 +23194,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_open_limit_tilt, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_installed_open_limit_tilt_undefine_reported( +@@ -23269,7 +23269,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_tilt( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_installed_closed_limit_tilt( ++int16_t dotdot_get_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23280,7 +23280,7 @@ uint16_t dotdot_get_window_covering_installed_closed_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23292,7 +23292,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_installed_closed_limit_tilt ++ int16_t new_installed_closed_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23305,7 +23305,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_closed_limit_tilt, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_installed_closed_limit_tilt_undefine_reported( +@@ -23380,7 +23380,7 @@ bool dotdot_is_supported_window_covering_velocity_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_velocity_lift( ++int16_t dotdot_get_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23391,7 +23391,7 @@ uint16_t dotdot_get_window_covering_velocity_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23403,7 +23403,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_velocity_lift ++ int16_t new_velocity_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23416,7 +23416,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_velocity_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_velocity_lift_undefine_reported( +@@ -23491,7 +23491,7 @@ bool dotdot_is_supported_window_covering_acceleration_time_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_acceleration_time_lift( ++int16_t dotdot_get_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23502,7 +23502,7 @@ uint16_t dotdot_get_window_covering_acceleration_time_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23514,7 +23514,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_acceleration_time_lift ++ int16_t new_acceleration_time_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23527,7 +23527,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_acceleration_time_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_acceleration_time_lift_undefine_reported( +@@ -23602,7 +23602,7 @@ bool dotdot_is_supported_window_covering_deceleration_time_lift( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_window_covering_deceleration_time_lift( ++int16_t dotdot_get_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23613,7 +23613,7 @@ uint16_t dotdot_get_window_covering_deceleration_time_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23625,7 +23625,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_deceleration_time_lift ++ int16_t new_deceleration_time_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23638,7 +23638,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_deceleration_time_lift, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_window_covering_deceleration_time_lift_undefine_reported( +@@ -23824,7 +23824,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_lift( + return attribute_store_node_exists(node); + } + +-const char* dotdot_get_window_covering_intermediate_setpoints_lift( ++uint8_t dotdot_get_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23847,7 +23847,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_intermediate_setpoints_lift ++ uint8_t new_intermediate_setpoints_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23936,7 +23936,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_tilt( + return attribute_store_node_exists(node); + } + +-const char* dotdot_get_window_covering_intermediate_setpoints_tilt( ++uint8_t dotdot_get_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23959,7 +23959,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- const char* new_intermediate_setpoints_tilt ++ uint8_t new_intermediate_setpoints_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24472,7 +24472,7 @@ bool dotdot_is_supported_barrier_control_open_events( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_open_events( ++int16_t dotdot_get_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24483,7 +24483,7 @@ uint16_t dotdot_get_barrier_control_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24495,7 +24495,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_events ++ int16_t new_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24508,7 +24508,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_events, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_open_events_undefine_reported( +@@ -24583,7 +24583,7 @@ bool dotdot_is_supported_barrier_control_close_events( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_close_events( ++int16_t dotdot_get_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24594,7 +24594,7 @@ uint16_t dotdot_get_barrier_control_close_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24606,7 +24606,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_close_events ++ int16_t new_close_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24619,7 +24619,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_close_events, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_close_events_undefine_reported( +@@ -24694,7 +24694,7 @@ bool dotdot_is_supported_barrier_control_command_open_events( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_command_open_events( ++int16_t dotdot_get_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24705,7 +24705,7 @@ uint16_t dotdot_get_barrier_control_command_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24717,7 +24717,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_command_open_events ++ int16_t new_command_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24730,7 +24730,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_command_open_events, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_command_open_events_undefine_reported( +@@ -24805,7 +24805,7 @@ bool dotdot_is_supported_barrier_control_command_close_events( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_command_close_events( ++int16_t dotdot_get_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24816,7 +24816,7 @@ uint16_t dotdot_get_barrier_control_command_close_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24828,7 +24828,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_command_close_events ++ int16_t new_command_close_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24841,7 +24841,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_command_close_events, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_command_close_events_undefine_reported( +@@ -24916,7 +24916,7 @@ bool dotdot_is_supported_barrier_control_open_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_open_period( ++int16_t dotdot_get_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24927,7 +24927,7 @@ uint16_t dotdot_get_barrier_control_open_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24939,7 +24939,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_open_period ++ int16_t new_open_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24952,7 +24952,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_open_period_undefine_reported( +@@ -25027,7 +25027,7 @@ bool dotdot_is_supported_barrier_control_close_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_barrier_control_close_period( ++int16_t dotdot_get_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25038,7 +25038,7 @@ uint16_t dotdot_get_barrier_control_close_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25050,7 +25050,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_close_period ++ int16_t new_close_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25063,7 +25063,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_close_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_barrier_control_close_period_undefine_reported( +@@ -25138,7 +25138,7 @@ bool dotdot_is_supported_barrier_control_barrier_position( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_barrier_control_barrier_position( ++int8_t dotdot_get_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25149,7 +25149,7 @@ uint8_t dotdot_get_barrier_control_barrier_position( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25161,7 +25161,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_barrier_position ++ int8_t new_barrier_position + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25174,7 +25174,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_barrier_position, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_barrier_control_barrier_position_undefine_reported( +@@ -25427,7 +25427,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_speed( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_max_speed( ++int16_t dotdot_get_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25438,7 +25438,7 @@ uint16_t dotdot_get_pump_configuration_and_control_max_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25450,7 +25450,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_speed ++ int16_t new_max_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25463,7 +25463,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_speed, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_speed_undefine_reported( +@@ -25538,7 +25538,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_flow( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_max_flow( ++int16_t dotdot_get_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25549,7 +25549,7 @@ uint16_t dotdot_get_pump_configuration_and_control_max_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25561,7 +25561,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_flow ++ int16_t new_max_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25574,7 +25574,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_flow, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_flow_undefine_reported( +@@ -26093,7 +26093,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_speed( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_min_const_speed( ++int16_t dotdot_get_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26104,7 +26104,7 @@ uint16_t dotdot_get_pump_configuration_and_control_min_const_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26116,7 +26116,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_const_speed ++ int16_t new_min_const_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26129,7 +26129,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_const_speed, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_min_const_speed_undefine_reported( +@@ -26204,7 +26204,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_speed( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_max_const_speed( ++int16_t dotdot_get_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26215,7 +26215,7 @@ uint16_t dotdot_get_pump_configuration_and_control_max_const_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26227,7 +26227,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_const_speed ++ int16_t new_max_const_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26240,7 +26240,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_const_speed, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_const_speed_undefine_reported( +@@ -26315,7 +26315,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_flow( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_min_const_flow( ++int16_t dotdot_get_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26326,7 +26326,7 @@ uint16_t dotdot_get_pump_configuration_and_control_min_const_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26338,7 +26338,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_const_flow ++ int16_t new_min_const_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26351,7 +26351,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_const_flow, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_min_const_flow_undefine_reported( +@@ -26426,7 +26426,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_flow( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_max_const_flow( ++int16_t dotdot_get_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26437,7 +26437,7 @@ uint16_t dotdot_get_pump_configuration_and_control_max_const_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26449,7 +26449,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_const_flow ++ int16_t new_max_const_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26462,7 +26462,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_const_flow, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_const_flow_undefine_reported( +@@ -27203,7 +27203,7 @@ bool dotdot_is_supported_pump_configuration_and_control_speed( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pump_configuration_and_control_speed( ++int16_t dotdot_get_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27214,7 +27214,7 @@ uint16_t dotdot_get_pump_configuration_and_control_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27226,7 +27226,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_speed ++ int16_t new_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27239,7 +27239,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_speed, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_speed_undefine_reported( +@@ -27314,7 +27314,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_running_hours( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( ++int32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27325,7 +27325,7 @@ uint32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27337,7 +27337,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lifetime_running_hours ++ int32_t new_lifetime_running_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27350,7 +27350,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lifetime_running_hours, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_lifetime_running_hours_undefine_reported( +@@ -27425,7 +27425,7 @@ bool dotdot_is_supported_pump_configuration_and_control_power( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_pump_configuration_and_control_power( ++int32_t dotdot_get_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27436,7 +27436,7 @@ uint32_t dotdot_get_pump_configuration_and_control_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27448,7 +27448,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power ++ int32_t new_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27461,7 +27461,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_power_undefine_reported( +@@ -27536,7 +27536,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_energy_consumed + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( ++int32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27547,7 +27547,7 @@ uint32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27559,7 +27559,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lifetime_energy_consumed ++ int32_t new_lifetime_energy_consumed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27572,7 +27572,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lifetime_energy_consumed, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_lifetime_energy_consumed_undefine_reported( +@@ -28860,7 +28860,7 @@ bool dotdot_is_supported_thermostat_pi_cooling_demand( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_pi_cooling_demand( ++int8_t dotdot_get_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -28871,7 +28871,7 @@ uint8_t dotdot_get_thermostat_pi_cooling_demand( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -28883,7 +28883,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pi_cooling_demand ++ int8_t new_pi_cooling_demand + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -28896,7 +28896,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pi_cooling_demand, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_pi_cooling_demand_undefine_reported( +@@ -28971,7 +28971,7 @@ bool dotdot_is_supported_thermostat_pi_heating_demand( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_pi_heating_demand( ++int8_t dotdot_get_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -28982,7 +28982,7 @@ uint8_t dotdot_get_thermostat_pi_heating_demand( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -28994,7 +28994,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pi_heating_demand ++ int8_t new_pi_heating_demand + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -29007,7 +29007,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pi_heating_demand, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_pi_heating_demand_undefine_reported( +@@ -30969,7 +30969,7 @@ bool dotdot_is_supported_thermostat_number_of_weekly_transitions( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_number_of_weekly_transitions( ++int8_t dotdot_get_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -30980,7 +30980,7 @@ uint8_t dotdot_get_thermostat_number_of_weekly_transitions( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -30992,7 +30992,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_weekly_transitions ++ int8_t new_number_of_weekly_transitions + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31005,7 +31005,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_weekly_transitions, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_number_of_weekly_transitions_undefine_reported( +@@ -31080,7 +31080,7 @@ bool dotdot_is_supported_thermostat_number_of_daily_transitions( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_number_of_daily_transitions( ++int8_t dotdot_get_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31091,7 +31091,7 @@ uint8_t dotdot_get_thermostat_number_of_daily_transitions( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31103,7 +31103,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_daily_transitions ++ int8_t new_number_of_daily_transitions + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31116,7 +31116,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_daily_transitions, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_number_of_daily_transitions_undefine_reported( +@@ -31302,7 +31302,7 @@ bool dotdot_is_supported_thermostat_temperature_setpoint_hold_duration( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( ++int16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31313,7 +31313,7 @@ uint16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31325,7 +31325,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_temperature_setpoint_hold_duration ++ int16_t new_temperature_setpoint_hold_duration + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31338,7 +31338,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_temperature_setpoint_hold_duration, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_thermostat_temperature_setpoint_hold_duration_undefine_reported( +@@ -31857,7 +31857,7 @@ bool dotdot_is_supported_thermostat_setpoint_change_source_timestamp( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_thermostat_setpoint_change_source_timestamp( ++uint8_t dotdot_get_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31868,7 +31868,7 @@ uint32_t dotdot_get_thermostat_setpoint_change_source_timestamp( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31880,7 +31880,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_setpoint_change_source_timestamp ++ uint8_t new_setpoint_change_source_timestamp + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31893,7 +31893,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_setpoint_change_source_timestamp, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_setpoint_change_source_timestamp_undefine_reported( +@@ -31968,7 +31968,7 @@ bool dotdot_is_supported_thermostat_occupied_setback( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_occupied_setback( ++int8_t dotdot_get_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31979,7 +31979,7 @@ uint8_t dotdot_get_thermostat_occupied_setback( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31991,7 +31991,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback ++ int8_t new_occupied_setback + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32004,7 +32004,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_undefine_reported( +@@ -32079,7 +32079,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_min( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_occupied_setback_min( ++int8_t dotdot_get_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32090,7 +32090,7 @@ uint8_t dotdot_get_thermostat_occupied_setback_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32102,7 +32102,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback_min ++ int8_t new_occupied_setback_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32115,7 +32115,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback_min, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_min_undefine_reported( +@@ -32190,7 +32190,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_max( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_occupied_setback_max( ++int8_t dotdot_get_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32201,7 +32201,7 @@ uint8_t dotdot_get_thermostat_occupied_setback_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32213,7 +32213,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_occupied_setback_max ++ int8_t new_occupied_setback_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32226,7 +32226,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback_max, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_max_undefine_reported( +@@ -32301,7 +32301,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_unoccupied_setback( ++int8_t dotdot_get_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32312,7 +32312,7 @@ uint8_t dotdot_get_thermostat_unoccupied_setback( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32324,7 +32324,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback ++ int8_t new_unoccupied_setback + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32337,7 +32337,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_undefine_reported( +@@ -32412,7 +32412,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_min( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_unoccupied_setback_min( ++int8_t dotdot_get_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32423,7 +32423,7 @@ uint8_t dotdot_get_thermostat_unoccupied_setback_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32435,7 +32435,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback_min ++ int8_t new_unoccupied_setback_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32448,7 +32448,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback_min, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_min_undefine_reported( +@@ -32523,7 +32523,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_max( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_unoccupied_setback_max( ++int8_t dotdot_get_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32534,7 +32534,7 @@ uint8_t dotdot_get_thermostat_unoccupied_setback_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32546,7 +32546,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_unoccupied_setback_max ++ int8_t new_unoccupied_setback_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32559,7 +32559,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback_max, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_max_undefine_reported( +@@ -32634,7 +32634,7 @@ bool dotdot_is_supported_thermostat_emergency_heat_delta( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_emergency_heat_delta( ++int8_t dotdot_get_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32645,7 +32645,7 @@ uint8_t dotdot_get_thermostat_emergency_heat_delta( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32657,7 +32657,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_emergency_heat_delta ++ int8_t new_emergency_heat_delta + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32670,7 +32670,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_emergency_heat_delta, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_thermostat_emergency_heat_delta_undefine_reported( +@@ -32856,7 +32856,7 @@ bool dotdot_is_supported_thermostat_ac_capacity( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_thermostat_ac_capacity( ++int16_t dotdot_get_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32867,7 +32867,7 @@ uint16_t dotdot_get_thermostat_ac_capacity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32879,7 +32879,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_capacity ++ int16_t new_ac_capacity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32892,7 +32892,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_capacity, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_thermostat_ac_capacity_undefine_reported( +@@ -34136,7 +34136,7 @@ bool dotdot_is_supported_dehumidification_control_relative_humidity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_dehumidification_control_relative_humidity( ++int8_t dotdot_get_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34147,7 +34147,7 @@ uint8_t dotdot_get_dehumidification_control_relative_humidity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34159,7 +34159,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_relative_humidity ++ int8_t new_relative_humidity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34172,7 +34172,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_relative_humidity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_dehumidification_control_relative_humidity_undefine_reported( +@@ -34247,7 +34247,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_cooling( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_dehumidification_control_dehumidification_cooling( ++int8_t dotdot_get_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34258,7 +34258,7 @@ uint8_t dotdot_get_dehumidification_control_dehumidification_cooling( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34270,7 +34270,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_cooling ++ int8_t new_dehumidification_cooling + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34283,7 +34283,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_cooling, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_cooling_undefine_reported( +@@ -34358,7 +34358,7 @@ bool dotdot_is_supported_dehumidification_control_rh_dehumidification_setpoint( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( ++int8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34369,7 +34369,7 @@ uint8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34381,7 +34381,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_rh_dehumidification_setpoint ++ int8_t new_rh_dehumidification_setpoint + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34394,7 +34394,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rh_dehumidification_setpoint, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_dehumidification_control_rh_dehumidification_setpoint_undefine_reported( +@@ -34691,7 +34691,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_hysteresis( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( ++int8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34702,7 +34702,7 @@ uint8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34714,7 +34714,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_hysteresis ++ int8_t new_dehumidification_hysteresis + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34727,7 +34727,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_hysteresis, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_hysteresis_undefine_reported( +@@ -34802,7 +34802,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_max_cool( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_dehumidification_control_dehumidification_max_cool( ++int8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34813,7 +34813,7 @@ uint8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34825,7 +34825,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidification_max_cool ++ int8_t new_dehumidification_max_cool + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34838,7 +34838,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_max_cool, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_max_cool_undefine_reported( +@@ -35455,7 +35455,7 @@ bool dotdot_is_supported_color_control_current_hue( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_current_hue( ++int8_t dotdot_get_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35466,7 +35466,7 @@ uint8_t dotdot_get_color_control_current_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35478,7 +35478,7 @@ sl_status_t dotdot_set_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_hue ++ int8_t new_current_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35491,7 +35491,7 @@ sl_status_t dotdot_set_color_control_current_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_hue, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_current_hue_undefine_reported( +@@ -35566,7 +35566,7 @@ bool dotdot_is_supported_color_control_current_saturation( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_current_saturation( ++int8_t dotdot_get_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35577,7 +35577,7 @@ uint8_t dotdot_get_color_control_current_saturation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35589,7 +35589,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_saturation ++ int8_t new_current_saturation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35602,7 +35602,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_saturation, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_current_saturation_undefine_reported( +@@ -35677,7 +35677,7 @@ bool dotdot_is_supported_color_control_remaining_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_remaining_time( ++int16_t dotdot_get_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35688,7 +35688,7 @@ uint16_t dotdot_get_color_control_remaining_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35700,7 +35700,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_remaining_time ++ int16_t new_remaining_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35713,7 +35713,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_remaining_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_remaining_time_undefine_reported( +@@ -35788,7 +35788,7 @@ bool dotdot_is_supported_color_control_currentx( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_currentx( ++int16_t dotdot_get_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35799,7 +35799,7 @@ uint16_t dotdot_get_color_control_currentx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35811,7 +35811,7 @@ sl_status_t dotdot_set_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_currentx ++ int16_t new_currentx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35824,7 +35824,7 @@ sl_status_t dotdot_set_color_control_currentx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_currentx, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_currentx_undefine_reported( +@@ -35899,7 +35899,7 @@ bool dotdot_is_supported_color_control_currenty( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_currenty( ++int16_t dotdot_get_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35910,7 +35910,7 @@ uint16_t dotdot_get_color_control_currenty( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35922,7 +35922,7 @@ sl_status_t dotdot_set_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_currenty ++ int16_t new_currenty + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35935,7 +35935,7 @@ sl_status_t dotdot_set_color_control_currenty( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_currenty, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_currenty_undefine_reported( +@@ -36233,7 +36233,7 @@ bool dotdot_is_supported_color_control_color_temperature_mireds( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_temperature_mireds( ++int16_t dotdot_get_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36244,7 +36244,7 @@ uint16_t dotdot_get_color_control_color_temperature_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36256,7 +36256,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temperature_mireds ++ int16_t new_color_temperature_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36269,7 +36269,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temperature_mireds, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_temperature_mireds_undefine_reported( +@@ -36566,7 +36566,7 @@ bool dotdot_is_supported_color_control_number_of_primaries( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_number_of_primaries( ++int8_t dotdot_get_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36577,7 +36577,7 @@ uint8_t dotdot_get_color_control_number_of_primaries( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36589,7 +36589,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_primaries ++ int8_t new_number_of_primaries + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36602,7 +36602,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_primaries, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_number_of_primaries_undefine_reported( +@@ -36677,7 +36677,7 @@ bool dotdot_is_supported_color_control_primary1x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary1x( ++int16_t dotdot_get_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36688,7 +36688,7 @@ uint16_t dotdot_get_color_control_primary1x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36700,7 +36700,7 @@ sl_status_t dotdot_set_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary1x ++ int16_t new_primary1x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36713,7 +36713,7 @@ sl_status_t dotdot_set_color_control_primary1x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary1x_undefine_reported( +@@ -36788,7 +36788,7 @@ bool dotdot_is_supported_color_control_primary1y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary1y( ++int16_t dotdot_get_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36799,7 +36799,7 @@ uint16_t dotdot_get_color_control_primary1y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36811,7 +36811,7 @@ sl_status_t dotdot_set_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary1y ++ int16_t new_primary1y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36824,7 +36824,7 @@ sl_status_t dotdot_set_color_control_primary1y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary1y_undefine_reported( +@@ -36899,7 +36899,7 @@ bool dotdot_is_supported_color_control_primary1_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary1_intensity( ++int8_t dotdot_get_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36910,7 +36910,7 @@ uint8_t dotdot_get_color_control_primary1_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36922,7 +36922,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary1_intensity ++ int8_t new_primary1_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36935,7 +36935,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary1_intensity_undefine_reported( +@@ -37010,7 +37010,7 @@ bool dotdot_is_supported_color_control_primary2x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary2x( ++int16_t dotdot_get_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37021,7 +37021,7 @@ uint16_t dotdot_get_color_control_primary2x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37033,7 +37033,7 @@ sl_status_t dotdot_set_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary2x ++ int16_t new_primary2x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37046,7 +37046,7 @@ sl_status_t dotdot_set_color_control_primary2x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary2x_undefine_reported( +@@ -37121,7 +37121,7 @@ bool dotdot_is_supported_color_control_primary2y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary2y( ++int16_t dotdot_get_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37132,7 +37132,7 @@ uint16_t dotdot_get_color_control_primary2y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37144,7 +37144,7 @@ sl_status_t dotdot_set_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary2y ++ int16_t new_primary2y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37157,7 +37157,7 @@ sl_status_t dotdot_set_color_control_primary2y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary2y_undefine_reported( +@@ -37232,7 +37232,7 @@ bool dotdot_is_supported_color_control_primary2_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary2_intensity( ++int8_t dotdot_get_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37243,7 +37243,7 @@ uint8_t dotdot_get_color_control_primary2_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37255,7 +37255,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary2_intensity ++ int8_t new_primary2_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37268,7 +37268,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary2_intensity_undefine_reported( +@@ -37343,7 +37343,7 @@ bool dotdot_is_supported_color_control_primary3x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary3x( ++int16_t dotdot_get_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37354,7 +37354,7 @@ uint16_t dotdot_get_color_control_primary3x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37366,7 +37366,7 @@ sl_status_t dotdot_set_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary3x ++ int16_t new_primary3x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37379,7 +37379,7 @@ sl_status_t dotdot_set_color_control_primary3x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary3x_undefine_reported( +@@ -37454,7 +37454,7 @@ bool dotdot_is_supported_color_control_primary3y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary3y( ++int16_t dotdot_get_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37465,7 +37465,7 @@ uint16_t dotdot_get_color_control_primary3y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37477,7 +37477,7 @@ sl_status_t dotdot_set_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary3y ++ int16_t new_primary3y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37490,7 +37490,7 @@ sl_status_t dotdot_set_color_control_primary3y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary3y_undefine_reported( +@@ -37565,7 +37565,7 @@ bool dotdot_is_supported_color_control_primary3_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary3_intensity( ++int8_t dotdot_get_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37576,7 +37576,7 @@ uint8_t dotdot_get_color_control_primary3_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37588,7 +37588,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary3_intensity ++ int8_t new_primary3_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37601,7 +37601,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary3_intensity_undefine_reported( +@@ -37676,7 +37676,7 @@ bool dotdot_is_supported_color_control_primary4x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary4x( ++int16_t dotdot_get_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37687,7 +37687,7 @@ uint16_t dotdot_get_color_control_primary4x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37699,7 +37699,7 @@ sl_status_t dotdot_set_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary4x ++ int16_t new_primary4x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37712,7 +37712,7 @@ sl_status_t dotdot_set_color_control_primary4x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary4x_undefine_reported( +@@ -37787,7 +37787,7 @@ bool dotdot_is_supported_color_control_primary4y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary4y( ++int16_t dotdot_get_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37798,7 +37798,7 @@ uint16_t dotdot_get_color_control_primary4y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37810,7 +37810,7 @@ sl_status_t dotdot_set_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary4y ++ int16_t new_primary4y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37823,7 +37823,7 @@ sl_status_t dotdot_set_color_control_primary4y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary4y_undefine_reported( +@@ -37898,7 +37898,7 @@ bool dotdot_is_supported_color_control_primary4_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary4_intensity( ++int8_t dotdot_get_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37909,7 +37909,7 @@ uint8_t dotdot_get_color_control_primary4_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37921,7 +37921,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary4_intensity ++ int8_t new_primary4_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37934,7 +37934,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary4_intensity_undefine_reported( +@@ -38009,7 +38009,7 @@ bool dotdot_is_supported_color_control_primary5x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary5x( ++int16_t dotdot_get_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38020,7 +38020,7 @@ uint16_t dotdot_get_color_control_primary5x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38032,7 +38032,7 @@ sl_status_t dotdot_set_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary5x ++ int16_t new_primary5x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38045,7 +38045,7 @@ sl_status_t dotdot_set_color_control_primary5x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary5x_undefine_reported( +@@ -38120,7 +38120,7 @@ bool dotdot_is_supported_color_control_primary5y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary5y( ++int16_t dotdot_get_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38131,7 +38131,7 @@ uint16_t dotdot_get_color_control_primary5y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38143,7 +38143,7 @@ sl_status_t dotdot_set_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary5y ++ int16_t new_primary5y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38156,7 +38156,7 @@ sl_status_t dotdot_set_color_control_primary5y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary5y_undefine_reported( +@@ -38231,7 +38231,7 @@ bool dotdot_is_supported_color_control_primary5_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary5_intensity( ++int8_t dotdot_get_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38242,7 +38242,7 @@ uint8_t dotdot_get_color_control_primary5_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38254,7 +38254,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary5_intensity ++ int8_t new_primary5_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38267,7 +38267,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary5_intensity_undefine_reported( +@@ -38342,7 +38342,7 @@ bool dotdot_is_supported_color_control_primary6x( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary6x( ++int16_t dotdot_get_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38353,7 +38353,7 @@ uint16_t dotdot_get_color_control_primary6x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38365,7 +38365,7 @@ sl_status_t dotdot_set_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary6x ++ int16_t new_primary6x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38378,7 +38378,7 @@ sl_status_t dotdot_set_color_control_primary6x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6x, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary6x_undefine_reported( +@@ -38453,7 +38453,7 @@ bool dotdot_is_supported_color_control_primary6y( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_primary6y( ++int16_t dotdot_get_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38464,7 +38464,7 @@ uint16_t dotdot_get_color_control_primary6y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38476,7 +38476,7 @@ sl_status_t dotdot_set_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_primary6y ++ int16_t new_primary6y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38489,7 +38489,7 @@ sl_status_t dotdot_set_color_control_primary6y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6y, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_primary6y_undefine_reported( +@@ -38564,7 +38564,7 @@ bool dotdot_is_supported_color_control_primary6_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_primary6_intensity( ++int8_t dotdot_get_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38575,7 +38575,7 @@ uint8_t dotdot_get_color_control_primary6_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38587,7 +38587,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_primary6_intensity ++ int8_t new_primary6_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38600,7 +38600,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_primary6_intensity_undefine_reported( +@@ -38675,7 +38675,7 @@ bool dotdot_is_supported_color_control_white_pointx( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_white_pointx( ++int16_t dotdot_get_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38686,7 +38686,7 @@ uint16_t dotdot_get_color_control_white_pointx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38698,7 +38698,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_white_pointx ++ int16_t new_white_pointx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38711,7 +38711,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_white_pointx, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_white_pointx_undefine_reported( +@@ -38786,7 +38786,7 @@ bool dotdot_is_supported_color_control_white_pointy( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_white_pointy( ++int16_t dotdot_get_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38797,7 +38797,7 @@ uint16_t dotdot_get_color_control_white_pointy( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38809,7 +38809,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_white_pointy ++ int16_t new_white_pointy + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38822,7 +38822,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_white_pointy, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_white_pointy_undefine_reported( +@@ -38897,7 +38897,7 @@ bool dotdot_is_supported_color_control_color_pointrx( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointrx( ++int16_t dotdot_get_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38908,7 +38908,7 @@ uint16_t dotdot_get_color_control_color_pointrx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38920,7 +38920,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointrx ++ int16_t new_color_pointrx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38933,7 +38933,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointrx, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointrx_undefine_reported( +@@ -39008,7 +39008,7 @@ bool dotdot_is_supported_color_control_color_pointry( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointry( ++int16_t dotdot_get_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39019,7 +39019,7 @@ uint16_t dotdot_get_color_control_color_pointry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39031,7 +39031,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointry ++ int16_t new_color_pointry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39044,7 +39044,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointry, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointry_undefine_reported( +@@ -39119,7 +39119,7 @@ bool dotdot_is_supported_color_control_color_pointr_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_color_pointr_intensity( ++int8_t dotdot_get_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39130,7 +39130,7 @@ uint8_t dotdot_get_color_control_color_pointr_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39142,7 +39142,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointr_intensity ++ int8_t new_color_pointr_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39155,7 +39155,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointr_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_color_pointr_intensity_undefine_reported( +@@ -39230,7 +39230,7 @@ bool dotdot_is_supported_color_control_color_pointgx( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointgx( ++int16_t dotdot_get_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39241,7 +39241,7 @@ uint16_t dotdot_get_color_control_color_pointgx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39253,7 +39253,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointgx ++ int16_t new_color_pointgx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39266,7 +39266,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointgx, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointgx_undefine_reported( +@@ -39341,7 +39341,7 @@ bool dotdot_is_supported_color_control_color_pointgy( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointgy( ++int16_t dotdot_get_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39352,7 +39352,7 @@ uint16_t dotdot_get_color_control_color_pointgy( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39364,7 +39364,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointgy ++ int16_t new_color_pointgy + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39377,7 +39377,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointgy, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointgy_undefine_reported( +@@ -39452,7 +39452,7 @@ bool dotdot_is_supported_color_control_color_pointg_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_color_pointg_intensity( ++int8_t dotdot_get_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39463,7 +39463,7 @@ uint8_t dotdot_get_color_control_color_pointg_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39475,7 +39475,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointg_intensity ++ int8_t new_color_pointg_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39488,7 +39488,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointg_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_color_pointg_intensity_undefine_reported( +@@ -39563,7 +39563,7 @@ bool dotdot_is_supported_color_control_color_pointbx( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointbx( ++int16_t dotdot_get_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39574,7 +39574,7 @@ uint16_t dotdot_get_color_control_color_pointbx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39586,7 +39586,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointbx ++ int16_t new_color_pointbx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39599,7 +39599,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointbx, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointbx_undefine_reported( +@@ -39674,7 +39674,7 @@ bool dotdot_is_supported_color_control_color_pointby( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_pointby( ++int16_t dotdot_get_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39685,7 +39685,7 @@ uint16_t dotdot_get_color_control_color_pointby( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39697,7 +39697,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_pointby ++ int16_t new_color_pointby + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39710,7 +39710,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointby, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_pointby_undefine_reported( +@@ -39785,7 +39785,7 @@ bool dotdot_is_supported_color_control_color_pointb_intensity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_color_pointb_intensity( ++int8_t dotdot_get_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39796,7 +39796,7 @@ uint8_t dotdot_get_color_control_color_pointb_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39808,7 +39808,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_pointb_intensity ++ int8_t new_color_pointb_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39821,7 +39821,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointb_intensity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_color_pointb_intensity_undefine_reported( +@@ -39896,7 +39896,7 @@ bool dotdot_is_supported_color_control_enhanced_current_hue( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_enhanced_current_hue( ++int16_t dotdot_get_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39907,7 +39907,7 @@ uint16_t dotdot_get_color_control_enhanced_current_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39919,7 +39919,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_enhanced_current_hue ++ int16_t new_enhanced_current_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39932,7 +39932,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_enhanced_current_hue, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_enhanced_current_hue_undefine_reported( +@@ -40118,7 +40118,7 @@ bool dotdot_is_supported_color_control_color_loop_active( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_color_loop_active( ++int8_t dotdot_get_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40129,7 +40129,7 @@ uint8_t dotdot_get_color_control_color_loop_active( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40141,7 +40141,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_loop_active ++ int8_t new_color_loop_active + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40154,7 +40154,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_active, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_color_loop_active_undefine_reported( +@@ -40229,7 +40229,7 @@ bool dotdot_is_supported_color_control_color_loop_direction( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_color_control_color_loop_direction( ++int8_t dotdot_get_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40240,7 +40240,7 @@ uint8_t dotdot_get_color_control_color_loop_direction( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40252,7 +40252,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_color_loop_direction ++ int8_t new_color_loop_direction + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40265,7 +40265,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_direction, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_color_control_color_loop_direction_undefine_reported( +@@ -40340,7 +40340,7 @@ bool dotdot_is_supported_color_control_color_loop_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_loop_time( ++int16_t dotdot_get_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40351,7 +40351,7 @@ uint16_t dotdot_get_color_control_color_loop_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40363,7 +40363,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_time ++ int16_t new_color_loop_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40376,7 +40376,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_loop_time_undefine_reported( +@@ -40451,7 +40451,7 @@ bool dotdot_is_supported_color_control_color_loop_start_enhanced_hue( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_loop_start_enhanced_hue( ++int16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40462,7 +40462,7 @@ uint16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40474,7 +40474,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_start_enhanced_hue ++ int16_t new_color_loop_start_enhanced_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40487,7 +40487,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_start_enhanced_hue, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_loop_start_enhanced_hue_undefine_reported( +@@ -40562,7 +40562,7 @@ bool dotdot_is_supported_color_control_color_loop_stored_enhanced_hue( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( ++int16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40573,7 +40573,7 @@ uint16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40585,7 +40585,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_loop_stored_enhanced_hue ++ int16_t new_color_loop_stored_enhanced_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40598,7 +40598,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_stored_enhanced_hue, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_loop_stored_enhanced_hue_undefine_reported( +@@ -40784,7 +40784,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_min_mireds( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_temp_physical_min_mireds( ++int16_t dotdot_get_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40795,7 +40795,7 @@ uint16_t dotdot_get_color_control_color_temp_physical_min_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40807,7 +40807,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temp_physical_min_mireds ++ int16_t new_color_temp_physical_min_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40820,7 +40820,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temp_physical_min_mireds, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_temp_physical_min_mireds_undefine_reported( +@@ -40895,7 +40895,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_max_mireds( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_color_temp_physical_max_mireds( ++int16_t dotdot_get_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40906,7 +40906,7 @@ uint16_t dotdot_get_color_control_color_temp_physical_max_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40918,7 +40918,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_color_temp_physical_max_mireds ++ int16_t new_color_temp_physical_max_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40931,7 +40931,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temp_physical_max_mireds, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_color_temp_physical_max_mireds_undefine_reported( +@@ -41006,7 +41006,7 @@ bool dotdot_is_supported_color_control_couple_color_temp_to_level_min_mireds( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( ++int16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41017,7 +41017,7 @@ uint16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41029,7 +41029,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_couple_color_temp_to_level_min_mireds ++ int16_t new_couple_color_temp_to_level_min_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41042,7 +41042,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_couple_color_temp_to_level_min_mireds, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_couple_color_temp_to_level_min_mireds_undefine_reported( +@@ -41117,7 +41117,7 @@ bool dotdot_is_supported_color_control_start_up_color_temperature_mireds( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_color_control_start_up_color_temperature_mireds( ++int16_t dotdot_get_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41128,7 +41128,7 @@ uint16_t dotdot_get_color_control_start_up_color_temperature_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41140,7 +41140,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_start_up_color_temperature_mireds ++ int16_t new_start_up_color_temperature_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41153,7 +41153,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_start_up_color_temperature_mireds, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_color_control_start_up_color_temperature_mireds_undefine_reported( +@@ -41442,7 +41442,7 @@ bool dotdot_is_supported_ballast_configuration_physical_min_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_physical_min_level( ++int8_t dotdot_get_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41453,7 +41453,7 @@ uint8_t dotdot_get_ballast_configuration_physical_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41465,7 +41465,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_min_level ++ int8_t new_physical_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41478,7 +41478,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_min_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_physical_min_level_undefine_reported( +@@ -41553,7 +41553,7 @@ bool dotdot_is_supported_ballast_configuration_physical_max_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_physical_max_level( ++int8_t dotdot_get_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41564,7 +41564,7 @@ uint8_t dotdot_get_ballast_configuration_physical_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41576,7 +41576,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_max_level ++ int8_t new_physical_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41589,7 +41589,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_max_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_physical_max_level_undefine_reported( +@@ -41775,7 +41775,7 @@ bool dotdot_is_supported_ballast_configuration_min_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_min_level( ++int8_t dotdot_get_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41786,7 +41786,7 @@ uint8_t dotdot_get_ballast_configuration_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41798,7 +41798,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_min_level ++ int8_t new_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41811,7 +41811,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_min_level_undefine_reported( +@@ -41886,7 +41886,7 @@ bool dotdot_is_supported_ballast_configuration_max_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_max_level( ++int8_t dotdot_get_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41897,7 +41897,7 @@ uint8_t dotdot_get_ballast_configuration_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41909,7 +41909,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_max_level ++ int8_t new_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41922,7 +41922,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_max_level_undefine_reported( +@@ -41997,7 +41997,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_power_on_level( ++int8_t dotdot_get_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42008,7 +42008,7 @@ uint8_t dotdot_get_ballast_configuration_power_on_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42020,7 +42020,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_power_on_level ++ int8_t new_power_on_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42033,7 +42033,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_on_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_power_on_level_undefine_reported( +@@ -42108,7 +42108,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_fade_time( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_ballast_configuration_power_on_fade_time( ++int16_t dotdot_get_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42119,7 +42119,7 @@ uint16_t dotdot_get_ballast_configuration_power_on_fade_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42131,7 +42131,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_power_on_fade_time ++ int16_t new_power_on_fade_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42144,7 +42144,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_on_fade_time, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_ballast_configuration_power_on_fade_time_undefine_reported( +@@ -42219,7 +42219,7 @@ bool dotdot_is_supported_ballast_configuration_intrinsic_ballast_factor( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( ++int8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42230,7 +42230,7 @@ uint8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42242,7 +42242,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intrinsic_ballast_factor ++ int8_t new_intrinsic_ballast_factor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42255,7 +42255,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_intrinsic_ballast_factor, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_intrinsic_ballast_factor_undefine_reported( +@@ -42330,7 +42330,7 @@ bool dotdot_is_supported_ballast_configuration_ballast_factor_adjustment( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( ++int8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42341,7 +42341,7 @@ uint8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42353,7 +42353,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_ballast_factor_adjustment ++ int8_t new_ballast_factor_adjustment + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42366,7 +42366,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ballast_factor_adjustment, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_ballast_factor_adjustment_undefine_reported( +@@ -42441,7 +42441,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_quantity( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ballast_configuration_lamp_quantity( ++int8_t dotdot_get_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42452,7 +42452,7 @@ uint8_t dotdot_get_ballast_configuration_lamp_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42464,7 +42464,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_lamp_quantity ++ int8_t new_lamp_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42477,7 +42477,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_quantity, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_quantity_undefine_reported( +@@ -42776,7 +42776,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_rated_hours( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_ballast_configuration_lamp_rated_hours( ++int32_t dotdot_get_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42787,7 +42787,7 @@ uint32_t dotdot_get_ballast_configuration_lamp_rated_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42799,7 +42799,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_rated_hours ++ int32_t new_lamp_rated_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42812,7 +42812,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_rated_hours, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_rated_hours_undefine_reported( +@@ -42887,7 +42887,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_ballast_configuration_lamp_burn_hours( ++int32_t dotdot_get_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42898,7 +42898,7 @@ uint32_t dotdot_get_ballast_configuration_lamp_burn_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42910,7 +42910,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_burn_hours ++ int32_t new_lamp_burn_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42923,7 +42923,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_burn_hours, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_burn_hours_undefine_reported( +@@ -43109,7 +43109,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours_trip_point( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( ++int32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43120,7 +43120,7 @@ uint32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43132,7 +43132,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_lamp_burn_hours_trip_point ++ int32_t new_lamp_burn_hours_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43145,7 +43145,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_burn_hours_trip_point, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_burn_hours_trip_point_undefine_reported( +@@ -43323,7 +43323,7 @@ bool dotdot_is_supported_illuminance_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_illuminance_measurement_measured_value( ++int16_t dotdot_get_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43334,7 +43334,7 @@ uint16_t dotdot_get_illuminance_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43346,7 +43346,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43359,7 +43359,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_illuminance_measurement_measured_value_undefine_reported( +@@ -43434,7 +43434,7 @@ bool dotdot_is_supported_illuminance_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_illuminance_measurement_min_measured_value( ++int16_t dotdot_get_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43445,7 +43445,7 @@ uint16_t dotdot_get_illuminance_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43457,7 +43457,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43470,7 +43470,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_illuminance_measurement_min_measured_value_undefine_reported( +@@ -43545,7 +43545,7 @@ bool dotdot_is_supported_illuminance_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_illuminance_measurement_max_measured_value( ++int16_t dotdot_get_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43556,7 +43556,7 @@ uint16_t dotdot_get_illuminance_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43568,7 +43568,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43581,7 +43581,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_illuminance_measurement_max_measured_value_undefine_reported( +@@ -43656,7 +43656,7 @@ bool dotdot_is_supported_illuminance_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_illuminance_measurement_tolerance( ++int16_t dotdot_get_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43667,7 +43667,7 @@ uint16_t dotdot_get_illuminance_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43679,7 +43679,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43692,7 +43692,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_illuminance_measurement_tolerance_undefine_reported( +@@ -44134,7 +44134,7 @@ bool dotdot_is_supported_illuminance_level_sensing_illuminance_target_level( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( ++int16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -44145,7 +44145,7 @@ uint16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -44157,7 +44157,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_illuminance_target_level ++ int16_t new_illuminance_target_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -44170,7 +44170,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_illuminance_target_level, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_illuminance_level_sensing_illuminance_target_level_undefine_reported( +@@ -44609,7 +44609,7 @@ bool dotdot_is_supported_temperature_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_temperature_measurement_tolerance( ++int16_t dotdot_get_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -44620,7 +44620,7 @@ uint16_t dotdot_get_temperature_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -44632,7 +44632,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -44645,7 +44645,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_temperature_measurement_tolerance_undefine_reported( +@@ -45084,7 +45084,7 @@ bool dotdot_is_supported_pressure_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pressure_measurement_tolerance( ++int16_t dotdot_get_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45095,7 +45095,7 @@ uint16_t dotdot_get_pressure_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45107,7 +45107,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45120,7 +45120,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pressure_measurement_tolerance_undefine_reported( +@@ -45528,7 +45528,7 @@ bool dotdot_is_supported_pressure_measurement_scaled_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_pressure_measurement_scaled_tolerance( ++int16_t dotdot_get_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45539,7 +45539,7 @@ uint16_t dotdot_get_pressure_measurement_scaled_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45551,7 +45551,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_scaled_tolerance ++ int16_t new_scaled_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45564,7 +45564,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_scaled_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_pressure_measurement_scaled_tolerance_undefine_reported( +@@ -45796,7 +45796,7 @@ bool dotdot_is_supported_flow_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_flow_measurement_measured_value( ++int16_t dotdot_get_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45807,7 +45807,7 @@ uint16_t dotdot_get_flow_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45819,7 +45819,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45832,7 +45832,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_flow_measurement_measured_value_undefine_reported( +@@ -45907,7 +45907,7 @@ bool dotdot_is_supported_flow_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_flow_measurement_min_measured_value( ++int16_t dotdot_get_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45918,7 +45918,7 @@ uint16_t dotdot_get_flow_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45930,7 +45930,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45943,7 +45943,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_flow_measurement_min_measured_value_undefine_reported( +@@ -46018,7 +46018,7 @@ bool dotdot_is_supported_flow_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_flow_measurement_max_measured_value( ++int16_t dotdot_get_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46029,7 +46029,7 @@ uint16_t dotdot_get_flow_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46041,7 +46041,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46054,7 +46054,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_flow_measurement_max_measured_value_undefine_reported( +@@ -46129,7 +46129,7 @@ bool dotdot_is_supported_flow_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_flow_measurement_tolerance( ++int16_t dotdot_get_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46140,7 +46140,7 @@ uint16_t dotdot_get_flow_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46152,7 +46152,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46165,7 +46165,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_flow_measurement_tolerance_undefine_reported( +@@ -46271,7 +46271,7 @@ bool dotdot_is_supported_relativity_humidity_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_relativity_humidity_measured_value( ++int16_t dotdot_get_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46282,7 +46282,7 @@ uint16_t dotdot_get_relativity_humidity_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46294,7 +46294,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46307,7 +46307,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_relativity_humidity_measured_value_undefine_reported( +@@ -46382,7 +46382,7 @@ bool dotdot_is_supported_relativity_humidity_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_relativity_humidity_min_measured_value( ++int16_t dotdot_get_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46393,7 +46393,7 @@ uint16_t dotdot_get_relativity_humidity_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46405,7 +46405,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46418,7 +46418,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_relativity_humidity_min_measured_value_undefine_reported( +@@ -46493,7 +46493,7 @@ bool dotdot_is_supported_relativity_humidity_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_relativity_humidity_max_measured_value( ++int16_t dotdot_get_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46504,7 +46504,7 @@ uint16_t dotdot_get_relativity_humidity_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46516,7 +46516,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46529,7 +46529,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_relativity_humidity_max_measured_value_undefine_reported( +@@ -46604,7 +46604,7 @@ bool dotdot_is_supported_relativity_humidity_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_relativity_humidity_tolerance( ++int16_t dotdot_get_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46615,7 +46615,7 @@ uint16_t dotdot_get_relativity_humidity_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46627,7 +46627,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46640,7 +46640,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_relativity_humidity_tolerance_undefine_reported( +@@ -47079,7 +47079,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_occupied_to_unoccupied_delay( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47090,7 +47090,7 @@ uint16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47102,7 +47102,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_pir_occupied_to_unoccupied_delay ++ int16_t new_pir_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47115,7 +47115,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_occupied_to_unoccupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_undefine_reported( +@@ -47190,7 +47190,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_delay( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47201,7 +47201,7 @@ uint16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47213,7 +47213,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_pir_unoccupied_to_occupied_delay ++ int16_t new_pir_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47226,7 +47226,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_unoccupied_to_occupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_undefine_reported( +@@ -47301,7 +47301,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47312,7 +47312,7 @@ uint8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47324,7 +47324,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_pir_unoccupied_to_occupied_threshold ++ int8_t new_pir_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47337,7 +47337,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_unoccupied_to_occupied_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_undefine_reported( +@@ -47412,7 +47412,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_occupied_to_unoccupied_del + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47423,7 +47423,7 @@ uint16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47435,7 +47435,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ultrasonic_occupied_to_unoccupied_delay ++ int16_t new_ultrasonic_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47448,7 +47448,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_occupied_to_unoccupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_undefine_reported( +@@ -47523,7 +47523,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_del + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47534,7 +47534,7 @@ uint16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47546,7 +47546,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ultrasonic_unoccupied_to_occupied_delay ++ int16_t new_ultrasonic_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47559,7 +47559,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_unoccupied_to_occupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_undefine_reported( +@@ -47634,7 +47634,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thr + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47645,7 +47645,7 @@ uint8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47657,7 +47657,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_ultrasonic_unoccupied_to_occupied_threshold ++ int8_t new_ultrasonic_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47670,7 +47670,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_unoccupied_to_occupied_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_undefine_reported( +@@ -47745,7 +47745,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_occupied_to_unoccupi + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( ++int16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47756,7 +47756,7 @@ uint16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_de + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47768,7 +47768,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_contact_occupied_to_unoccupied_delay ++ int16_t new_physical_contact_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47781,7 +47781,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_occupied_to_unoccupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_undefine_reported( +@@ -47856,7 +47856,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( ++int16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47867,7 +47867,7 @@ uint16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_de + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47879,7 +47879,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_physical_contact_unoccupied_to_occupied_delay ++ int16_t new_physical_contact_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47892,7 +47892,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_unoccupied_to_occupied_delay, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_undefine_reported( +@@ -47967,7 +47967,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( ++int8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47978,7 +47978,7 @@ uint8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_thr + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47990,7 +47990,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_physical_contact_unoccupied_to_occupied_threshold ++ int8_t new_physical_contact_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48003,7 +48003,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_unoccupied_to_occupied_threshold, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_undefine_reported( +@@ -48160,7 +48160,7 @@ bool dotdot_is_supported_soil_moisture_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_soil_moisture_measured_value( ++int16_t dotdot_get_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48171,7 +48171,7 @@ uint16_t dotdot_get_soil_moisture_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48183,7 +48183,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48196,7 +48196,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_soil_moisture_measured_value_undefine_reported( +@@ -48271,7 +48271,7 @@ bool dotdot_is_supported_soil_moisture_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_soil_moisture_min_measured_value( ++int16_t dotdot_get_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48282,7 +48282,7 @@ uint16_t dotdot_get_soil_moisture_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48294,7 +48294,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48307,7 +48307,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_soil_moisture_min_measured_value_undefine_reported( +@@ -48382,7 +48382,7 @@ bool dotdot_is_supported_soil_moisture_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_soil_moisture_max_measured_value( ++int16_t dotdot_get_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48393,7 +48393,7 @@ uint16_t dotdot_get_soil_moisture_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48405,7 +48405,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48418,7 +48418,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_soil_moisture_max_measured_value_undefine_reported( +@@ -48493,7 +48493,7 @@ bool dotdot_is_supported_soil_moisture_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_soil_moisture_tolerance( ++int16_t dotdot_get_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48504,7 +48504,7 @@ uint16_t dotdot_get_soil_moisture_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48516,7 +48516,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48529,7 +48529,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_soil_moisture_tolerance_undefine_reported( +@@ -48635,7 +48635,7 @@ bool dotdot_is_supported_ph_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_ph_measurement_measured_value( ++int16_t dotdot_get_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48646,7 +48646,7 @@ uint16_t dotdot_get_ph_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48658,7 +48658,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48671,7 +48671,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_ph_measurement_measured_value_undefine_reported( +@@ -48746,7 +48746,7 @@ bool dotdot_is_supported_ph_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_ph_measurement_min_measured_value( ++int16_t dotdot_get_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48757,7 +48757,7 @@ uint16_t dotdot_get_ph_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48769,7 +48769,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48782,7 +48782,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_ph_measurement_min_measured_value_undefine_reported( +@@ -48857,7 +48857,7 @@ bool dotdot_is_supported_ph_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_ph_measurement_max_measured_value( ++int16_t dotdot_get_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48868,7 +48868,7 @@ uint16_t dotdot_get_ph_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48880,7 +48880,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48893,7 +48893,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_ph_measurement_max_measured_value_undefine_reported( +@@ -48968,7 +48968,7 @@ bool dotdot_is_supported_ph_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_ph_measurement_tolerance( ++int16_t dotdot_get_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48979,7 +48979,7 @@ uint16_t dotdot_get_ph_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48991,7 +48991,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49004,7 +49004,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_ph_measurement_tolerance_undefine_reported( +@@ -49110,7 +49110,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_conductivity_measurement_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49121,7 +49121,7 @@ uint16_t dotdot_get_electrical_conductivity_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49133,7 +49133,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49146,7 +49146,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_measured_value_undefine_reported( +@@ -49221,7 +49221,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49232,7 +49232,7 @@ uint16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49244,7 +49244,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49257,7 +49257,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_min_measured_value_undefine_reported( +@@ -49332,7 +49332,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( ++int16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49343,7 +49343,7 @@ uint16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49355,7 +49355,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49368,7 +49368,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_max_measured_value_undefine_reported( +@@ -49443,7 +49443,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_conductivity_measurement_tolerance( ++int16_t dotdot_get_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49454,7 +49454,7 @@ uint16_t dotdot_get_electrical_conductivity_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49466,7 +49466,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49479,7 +49479,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_tolerance_undefine_reported( +@@ -49585,7 +49585,7 @@ bool dotdot_is_supported_wind_speed_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_wind_speed_measurement_measured_value( ++int16_t dotdot_get_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49596,7 +49596,7 @@ uint16_t dotdot_get_wind_speed_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49608,7 +49608,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_measured_value ++ int16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49621,7 +49621,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_measured_value_undefine_reported( +@@ -49696,7 +49696,7 @@ bool dotdot_is_supported_wind_speed_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_wind_speed_measurement_min_measured_value( ++int16_t dotdot_get_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49707,7 +49707,7 @@ uint16_t dotdot_get_wind_speed_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49719,7 +49719,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_min_measured_value ++ int16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49732,7 +49732,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_min_measured_value_undefine_reported( +@@ -49807,7 +49807,7 @@ bool dotdot_is_supported_wind_speed_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_wind_speed_measurement_max_measured_value( ++int16_t dotdot_get_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49818,7 +49818,7 @@ uint16_t dotdot_get_wind_speed_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49830,7 +49830,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_measured_value ++ int16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49843,7 +49843,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_max_measured_value_undefine_reported( +@@ -49918,7 +49918,7 @@ bool dotdot_is_supported_wind_speed_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_wind_speed_measurement_tolerance( ++int16_t dotdot_get_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49929,7 +49929,7 @@ uint16_t dotdot_get_wind_speed_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49941,7 +49941,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_tolerance ++ int16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49954,7 +49954,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_tolerance_undefine_reported( +@@ -51929,7 +51929,7 @@ bool dotdot_is_supported_ias_zone_zoneid( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ias_zone_zoneid( ++int8_t dotdot_get_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -51940,7 +51940,7 @@ uint8_t dotdot_get_ias_zone_zoneid( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -51952,7 +51952,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_zoneid ++ int8_t new_zoneid + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -51965,7 +51965,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_zoneid, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ias_zone_zoneid_undefine_reported( +@@ -52040,7 +52040,7 @@ bool dotdot_is_supported_ias_zone_number_of_zone_sensitivity_levels_supported( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( ++int8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52051,7 +52051,7 @@ uint8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52063,7 +52063,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_number_of_zone_sensitivity_levels_supported ++ int8_t new_number_of_zone_sensitivity_levels_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52076,7 +52076,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_zone_sensitivity_levels_supported, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_undefine_reported( +@@ -52151,7 +52151,7 @@ bool dotdot_is_supported_ias_zone_current_zone_sensitivity_level( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_ias_zone_current_zone_sensitivity_level( ++int8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52162,7 +52162,7 @@ uint8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52174,7 +52174,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_zone_sensitivity_level ++ int8_t new_current_zone_sensitivity_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52187,7 +52187,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_zone_sensitivity_level, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_ias_zone_current_zone_sensitivity_level_undefine_reported( +@@ -52308,7 +52308,7 @@ bool dotdot_is_supported_iaswd_max_duration( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_iaswd_max_duration( ++int16_t dotdot_get_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52319,7 +52319,7 @@ uint16_t dotdot_get_iaswd_max_duration( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52331,7 +52331,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_max_duration ++ int16_t new_max_duration + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52344,7 +52344,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_duration, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_iaswd_max_duration_undefine_reported( +@@ -52444,7 +52444,7 @@ bool dotdot_is_supported_metering_current_summation_delivered( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_metering_current_summation_delivered( ++int64_t dotdot_get_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52455,7 +52455,7 @@ uint64_t dotdot_get_metering_current_summation_delivered( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52467,7 +52467,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_summation_delivered ++ int64_t new_current_summation_delivered + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52480,7 +52480,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_summation_delivered, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_metering_current_summation_delivered_undefine_reported( +@@ -52555,7 +52555,7 @@ bool dotdot_is_supported_metering_current_summation_received( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_metering_current_summation_received( ++int64_t dotdot_get_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52566,7 +52566,7 @@ uint64_t dotdot_get_metering_current_summation_received( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52578,7 +52578,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_summation_received ++ int64_t new_current_summation_received + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52591,7 +52591,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_summation_received, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_metering_current_summation_received_undefine_reported( +@@ -52666,7 +52666,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_metering_current_max_demand_delivered( ++int64_t dotdot_get_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52677,7 +52677,7 @@ uint64_t dotdot_get_metering_current_max_demand_delivered( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52689,7 +52689,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_max_demand_delivered ++ int64_t new_current_max_demand_delivered + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52702,7 +52702,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_delivered, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_metering_current_max_demand_delivered_undefine_reported( +@@ -52999,7 +52999,7 @@ bool dotdot_is_supported_metering_reading_snap_shot_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_metering_reading_snap_shot_time( ++uint8_t dotdot_get_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53010,7 +53010,7 @@ uint32_t dotdot_get_metering_reading_snap_shot_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53022,7 +53022,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_reading_snap_shot_time ++ uint8_t new_reading_snap_shot_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53035,7 +53035,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_reading_snap_shot_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_metering_reading_snap_shot_time_undefine_reported( +@@ -53110,7 +53110,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_metering_current_max_demand_delivered_time( ++uint8_t dotdot_get_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53121,7 +53121,7 @@ uint32_t dotdot_get_metering_current_max_demand_delivered_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53133,7 +53133,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_current_max_demand_delivered_time ++ uint8_t new_current_max_demand_delivered_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53146,7 +53146,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_delivered_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_metering_current_max_demand_delivered_time_undefine_reported( +@@ -53221,7 +53221,7 @@ bool dotdot_is_supported_metering_current_max_demand_received_time( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_metering_current_max_demand_received_time( ++uint8_t dotdot_get_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53232,7 +53232,7 @@ uint32_t dotdot_get_metering_current_max_demand_received_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME); + +- uint32_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53244,7 +53244,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_current_max_demand_received_time ++ uint8_t new_current_max_demand_received_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53257,7 +53257,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_received_time, +- sizeof(uint32_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_metering_current_max_demand_received_time_undefine_reported( +@@ -53332,7 +53332,7 @@ bool dotdot_is_supported_metering_default_update_period( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_metering_default_update_period( ++int8_t dotdot_get_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53343,7 +53343,7 @@ uint8_t dotdot_get_metering_default_update_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53355,7 +53355,7 @@ sl_status_t dotdot_set_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_default_update_period ++ int8_t new_default_update_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53368,7 +53368,7 @@ sl_status_t dotdot_set_metering_default_update_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_default_update_period, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_metering_default_update_period_undefine_reported( +@@ -53554,7 +53554,7 @@ bool dotdot_is_supported_metering_current_inlet_energy_carrier_summation( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_metering_current_inlet_energy_carrier_summation( ++int64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53565,7 +53565,7 @@ uint64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53577,7 +53577,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_inlet_energy_carrier_summation ++ int64_t new_current_inlet_energy_carrier_summation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53590,7 +53590,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_inlet_energy_carrier_summation, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_metering_current_inlet_energy_carrier_summation_undefine_reported( +@@ -53665,7 +53665,7 @@ bool dotdot_is_supported_metering_current_outlet_energy_carrier_summation( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_metering_current_outlet_energy_carrier_summation( ++int64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53676,7 +53676,7 @@ uint64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53688,7 +53688,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_current_outlet_energy_carrier_summation ++ int64_t new_current_outlet_energy_carrier_summation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53701,7 +53701,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_outlet_energy_carrier_summation, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_metering_current_outlet_energy_carrier_summation_undefine_reported( +@@ -54109,7 +54109,7 @@ bool dotdot_is_supported_metering_multiplier( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_metering_multiplier( ++int32_t dotdot_get_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -54120,7 +54120,7 @@ uint32_t dotdot_get_metering_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -54132,7 +54132,7 @@ sl_status_t dotdot_set_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_multiplier ++ int32_t new_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -54145,7 +54145,7 @@ sl_status_t dotdot_set_metering_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_multiplier, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_metering_multiplier_undefine_reported( +@@ -54220,7 +54220,7 @@ bool dotdot_is_supported_metering_divisor( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_metering_divisor( ++int32_t dotdot_get_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -54231,7 +54231,7 @@ uint32_t dotdot_get_metering_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -54243,7 +54243,7 @@ sl_status_t dotdot_set_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_divisor ++ int32_t new_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -54256,7 +54256,7 @@ sl_status_t dotdot_set_metering_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_divisor, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_metering_divisor_undefine_reported( +@@ -56537,7 +56537,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56548,7 +56548,7 @@ uint16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56560,7 +56560,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_voltage_multiplier ++ int16_t new_dc_voltage_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56573,7 +56573,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_voltage_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_voltage_multiplier_undefine_reported( +@@ -56648,7 +56648,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_voltage_divisor( ++int16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56659,7 +56659,7 @@ uint16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56671,7 +56671,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_voltage_divisor ++ int16_t new_dc_voltage_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56684,7 +56684,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_voltage_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_voltage_divisor_undefine_reported( +@@ -56759,7 +56759,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_current_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56770,7 +56770,7 @@ uint16_t dotdot_get_electrical_measurement_dc_current_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56782,7 +56782,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_current_multiplier ++ int16_t new_dc_current_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56795,7 +56795,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_current_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_current_multiplier_undefine_reported( +@@ -56870,7 +56870,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_current_divisor( ++int16_t dotdot_get_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56881,7 +56881,7 @@ uint16_t dotdot_get_electrical_measurement_dc_current_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56893,7 +56893,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_current_divisor ++ int16_t new_dc_current_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56906,7 +56906,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_current_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_current_divisor_undefine_reported( +@@ -56981,7 +56981,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_power_multiplier( ++int16_t dotdot_get_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56992,7 +56992,7 @@ uint16_t dotdot_get_electrical_measurement_dc_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57004,7 +57004,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_power_multiplier ++ int16_t new_dc_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57017,7 +57017,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_power_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_power_multiplier_undefine_reported( +@@ -57092,7 +57092,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_dc_power_divisor( ++int16_t dotdot_get_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57103,7 +57103,7 @@ uint16_t dotdot_get_electrical_measurement_dc_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57115,7 +57115,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_dc_power_divisor ++ int16_t new_dc_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57128,7 +57128,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_power_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_power_divisor_undefine_reported( +@@ -57203,7 +57203,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_frequency( ++int16_t dotdot_get_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57214,7 +57214,7 @@ uint16_t dotdot_get_electrical_measurement_ac_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57226,7 +57226,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency ++ int16_t new_ac_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57239,7 +57239,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_undefine_reported( +@@ -57314,7 +57314,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_min( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_frequency_min( ++int16_t dotdot_get_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57325,7 +57325,7 @@ uint16_t dotdot_get_electrical_measurement_ac_frequency_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57337,7 +57337,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_min ++ int16_t new_ac_frequency_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57350,7 +57350,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_min, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_min_undefine_reported( +@@ -57425,7 +57425,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_max( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_frequency_max( ++int16_t dotdot_get_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57436,7 +57436,7 @@ uint16_t dotdot_get_electrical_measurement_ac_frequency_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57448,7 +57448,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_max ++ int16_t new_ac_frequency_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57461,7 +57461,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_max, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_max_undefine_reported( +@@ -57536,7 +57536,7 @@ bool dotdot_is_supported_electrical_measurement_neutral_current( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_neutral_current( ++int16_t dotdot_get_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57547,7 +57547,7 @@ uint16_t dotdot_get_electrical_measurement_neutral_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57559,7 +57559,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neutral_current ++ int16_t new_neutral_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57572,7 +57572,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neutral_current, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_neutral_current_undefine_reported( +@@ -57869,7 +57869,7 @@ bool dotdot_is_supported_electrical_measurement_total_apparent_power( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_electrical_measurement_total_apparent_power( ++int32_t dotdot_get_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57880,7 +57880,7 @@ uint32_t dotdot_get_electrical_measurement_total_apparent_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57892,7 +57892,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_total_apparent_power ++ int32_t new_total_apparent_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57905,7 +57905,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_total_apparent_power, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_electrical_measurement_total_apparent_power_undefine_reported( +@@ -59312,7 +59312,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59323,7 +59323,7 @@ uint16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59335,7 +59335,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_multiplier ++ int16_t new_ac_frequency_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59348,7 +59348,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_multiplier_undefine_reported( +@@ -59423,7 +59423,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_frequency_divisor( ++int16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59434,7 +59434,7 @@ uint16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59446,7 +59446,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_frequency_divisor ++ int16_t new_ac_frequency_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59459,7 +59459,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_divisor_undefine_reported( +@@ -59534,7 +59534,7 @@ bool dotdot_is_supported_electrical_measurement_power_multiplier( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_electrical_measurement_power_multiplier( ++int32_t dotdot_get_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59545,7 +59545,7 @@ uint32_t dotdot_get_electrical_measurement_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59557,7 +59557,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power_multiplier ++ int32_t new_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59570,7 +59570,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_multiplier, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_electrical_measurement_power_multiplier_undefine_reported( +@@ -59645,7 +59645,7 @@ bool dotdot_is_supported_electrical_measurement_power_divisor( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_electrical_measurement_power_divisor( ++int32_t dotdot_get_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59656,7 +59656,7 @@ uint32_t dotdot_get_electrical_measurement_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59668,7 +59668,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_power_divisor ++ int32_t new_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59681,7 +59681,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_divisor, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_electrical_measurement_power_divisor_undefine_reported( +@@ -59978,7 +59978,7 @@ bool dotdot_is_supported_electrical_measurement_line_current( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_line_current( ++int16_t dotdot_get_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59989,7 +59989,7 @@ uint16_t dotdot_get_electrical_measurement_line_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60001,7 +60001,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current ++ int16_t new_line_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60014,7 +60014,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_undefine_reported( +@@ -60311,7 +60311,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage( ++int16_t dotdot_get_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60322,7 +60322,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60334,7 +60334,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage ++ int16_t new_rms_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60347,7 +60347,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_undefine_reported( +@@ -60422,7 +60422,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60433,7 +60433,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60445,7 +60445,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min ++ int16_t new_rms_voltage_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60458,7 +60458,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_undefine_reported( +@@ -60533,7 +60533,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60544,7 +60544,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60556,7 +60556,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max ++ int16_t new_rms_voltage_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60569,7 +60569,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_undefine_reported( +@@ -60644,7 +60644,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current( ++int16_t dotdot_get_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60655,7 +60655,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60667,7 +60667,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current ++ int16_t new_rms_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60680,7 +60680,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_undefine_reported( +@@ -60755,7 +60755,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_min( ++int16_t dotdot_get_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60766,7 +60766,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60778,7 +60778,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min ++ int16_t new_rms_current_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60791,7 +60791,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_undefine_reported( +@@ -60866,7 +60866,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_max( ++int16_t dotdot_get_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60877,7 +60877,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60889,7 +60889,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max ++ int16_t new_rms_current_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60902,7 +60902,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_undefine_reported( +@@ -61421,7 +61421,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_apparent_power( ++int16_t dotdot_get_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61432,7 +61432,7 @@ uint16_t dotdot_get_electrical_measurement_apparent_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61444,7 +61444,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power ++ int16_t new_apparent_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61457,7 +61457,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_undefine_reported( +@@ -61643,7 +61643,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61654,7 +61654,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_perio + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61666,7 +61666,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period ++ int16_t new_average_rms_voltage_measurement_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61679,7 +61679,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_undefine_reported( +@@ -61754,7 +61754,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61765,7 +61765,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61777,7 +61777,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter ++ int16_t new_average_rms_over_voltage_counter + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61790,7 +61790,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_undefine_reported( +@@ -61865,7 +61865,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61876,7 +61876,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61888,7 +61888,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter ++ int16_t new_average_rms_under_voltage_counter + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61901,7 +61901,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_undefine_reported( +@@ -61976,7 +61976,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61987,7 +61987,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61999,7 +61999,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period ++ int16_t new_rms_extreme_over_voltage_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62012,7 +62012,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_undefine_reported( +@@ -62087,7 +62087,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62098,7 +62098,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62110,7 +62110,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period ++ int16_t new_rms_extreme_under_voltage_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62123,7 +62123,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_undefine_reported( +@@ -62198,7 +62198,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62209,7 +62209,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62221,7 +62221,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period ++ int16_t new_rms_voltage_sag_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62234,7 +62234,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_undefine_reported( +@@ -62309,7 +62309,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62320,7 +62320,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62332,7 +62332,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period ++ int16_t new_rms_voltage_swell_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62345,7 +62345,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_undefine_reported( +@@ -62420,7 +62420,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62431,7 +62431,7 @@ uint16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62443,7 +62443,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_voltage_multiplier ++ int16_t new_ac_voltage_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62456,7 +62456,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_voltage_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_voltage_multiplier_undefine_reported( +@@ -62531,7 +62531,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_voltage_divisor( ++int16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62542,7 +62542,7 @@ uint16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62554,7 +62554,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_voltage_divisor ++ int16_t new_ac_voltage_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62567,7 +62567,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_voltage_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_voltage_divisor_undefine_reported( +@@ -62642,7 +62642,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_current_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62653,7 +62653,7 @@ uint16_t dotdot_get_electrical_measurement_ac_current_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62665,7 +62665,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_current_multiplier ++ int16_t new_ac_current_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62678,7 +62678,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_current_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_current_multiplier_undefine_reported( +@@ -62753,7 +62753,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_current_divisor( ++int16_t dotdot_get_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62764,7 +62764,7 @@ uint16_t dotdot_get_electrical_measurement_ac_current_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62776,7 +62776,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_current_divisor ++ int16_t new_ac_current_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62789,7 +62789,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_current_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_current_divisor_undefine_reported( +@@ -62864,7 +62864,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_multiplier( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_power_multiplier( ++int16_t dotdot_get_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62875,7 +62875,7 @@ uint16_t dotdot_get_electrical_measurement_ac_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62887,7 +62887,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_power_multiplier ++ int16_t new_ac_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62900,7 +62900,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_power_multiplier, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_power_multiplier_undefine_reported( +@@ -62975,7 +62975,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_divisor( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_ac_power_divisor( ++int16_t dotdot_get_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62986,7 +62986,7 @@ uint16_t dotdot_get_electrical_measurement_ac_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62998,7 +62998,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_ac_power_divisor ++ int16_t new_ac_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -63011,7 +63011,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_power_divisor, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_power_divisor_undefine_reported( +@@ -64640,7 +64640,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_line_current_phb( ++int16_t dotdot_get_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -64651,7 +64651,7 @@ uint16_t dotdot_get_electrical_measurement_line_current_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -64663,7 +64663,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current_phb ++ int16_t new_line_current_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -64676,7 +64676,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_phb_undefine_reported( +@@ -64973,7 +64973,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -64984,7 +64984,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -64996,7 +64996,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_phb ++ int16_t new_rms_voltage_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65009,7 +65009,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_phb_undefine_reported( +@@ -65084,7 +65084,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65095,7 +65095,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65107,7 +65107,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min_phb ++ int16_t new_rms_voltage_min_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65120,7 +65120,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_phb_undefine_reported( +@@ -65195,7 +65195,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65206,7 +65206,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65218,7 +65218,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max_phb ++ int16_t new_rms_voltage_max_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65231,7 +65231,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_phb_undefine_reported( +@@ -65306,7 +65306,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65317,7 +65317,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65329,7 +65329,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_phb ++ int16_t new_rms_current_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65342,7 +65342,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_phb_undefine_reported( +@@ -65417,7 +65417,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_min_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65428,7 +65428,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_min_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65440,7 +65440,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min_phb ++ int16_t new_rms_current_min_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65453,7 +65453,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_phb_undefine_reported( +@@ -65528,7 +65528,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_max_phb( ++int16_t dotdot_get_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65539,7 +65539,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_max_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65551,7 +65551,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max_phb ++ int16_t new_rms_current_max_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65564,7 +65564,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_phb_undefine_reported( +@@ -66083,7 +66083,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_apparent_power_phb( ++int16_t dotdot_get_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66094,7 +66094,7 @@ uint16_t dotdot_get_electrical_measurement_apparent_power_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66106,7 +66106,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power_phb ++ int16_t new_apparent_power_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66119,7 +66119,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_phb_undefine_reported( +@@ -66305,7 +66305,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66316,7 +66316,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_perio + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66328,7 +66328,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period_phb ++ int16_t new_average_rms_voltage_measurement_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66341,7 +66341,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_undefine_reported( +@@ -66416,7 +66416,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66427,7 +66427,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66439,7 +66439,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter_phb ++ int16_t new_average_rms_over_voltage_counter_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66452,7 +66452,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_undefine_reported( +@@ -66527,7 +66527,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66538,7 +66538,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66550,7 +66550,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter_phb ++ int16_t new_average_rms_under_voltage_counter_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66563,7 +66563,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_undefine_reported( +@@ -66638,7 +66638,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66649,7 +66649,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66661,7 +66661,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period_phb ++ int16_t new_rms_extreme_over_voltage_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66674,7 +66674,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_undefine_reported( +@@ -66749,7 +66749,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66760,7 +66760,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66772,7 +66772,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period_phb ++ int16_t new_rms_extreme_under_voltage_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66785,7 +66785,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_undefine_reported( +@@ -66860,7 +66860,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66871,7 +66871,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66883,7 +66883,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period_phb ++ int16_t new_rms_voltage_sag_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66896,7 +66896,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_phb_undefine_reported( +@@ -66971,7 +66971,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phb( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66982,7 +66982,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66994,7 +66994,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period_phb ++ int16_t new_rms_voltage_swell_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67007,7 +67007,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period_phb, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_phb_undefine_reported( +@@ -67082,7 +67082,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_line_current_phc( ++int16_t dotdot_get_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67093,7 +67093,7 @@ uint16_t dotdot_get_electrical_measurement_line_current_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67105,7 +67105,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_line_current_phc ++ int16_t new_line_current_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67118,7 +67118,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_phc_undefine_reported( +@@ -67415,7 +67415,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67426,7 +67426,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67438,7 +67438,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_phc ++ int16_t new_rms_voltage_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67451,7 +67451,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_phc_undefine_reported( +@@ -67526,7 +67526,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67537,7 +67537,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67549,7 +67549,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_min_phc ++ int16_t new_rms_voltage_min_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67562,7 +67562,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_phc_undefine_reported( +@@ -67637,7 +67637,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67648,7 +67648,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67660,7 +67660,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_max_phc ++ int16_t new_rms_voltage_max_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67673,7 +67673,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_phc_undefine_reported( +@@ -67748,7 +67748,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67759,7 +67759,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67771,7 +67771,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_phc ++ int16_t new_rms_current_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67784,7 +67784,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_phc_undefine_reported( +@@ -67859,7 +67859,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_min_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67870,7 +67870,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_min_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67882,7 +67882,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_min_phc ++ int16_t new_rms_current_min_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67895,7 +67895,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_phc_undefine_reported( +@@ -67970,7 +67970,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_current_max_phc( ++int16_t dotdot_get_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67981,7 +67981,7 @@ uint16_t dotdot_get_electrical_measurement_rms_current_max_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67993,7 +67993,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_current_max_phc ++ int16_t new_rms_current_max_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68006,7 +68006,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_phc_undefine_reported( +@@ -68525,7 +68525,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_apparent_power_phc( ++int16_t dotdot_get_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68536,7 +68536,7 @@ uint16_t dotdot_get_electrical_measurement_apparent_power_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68548,7 +68548,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apparent_power_phc ++ int16_t new_apparent_power_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68561,7 +68561,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_phc_undefine_reported( +@@ -68747,7 +68747,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68758,7 +68758,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_perio + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68770,7 +68770,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_voltage_measurement_period_phc ++ int16_t new_average_rms_voltage_measurement_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68783,7 +68783,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_undefine_reported( +@@ -68858,7 +68858,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68869,7 +68869,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68881,7 +68881,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_over_voltage_counter_phc ++ int16_t new_average_rms_over_voltage_counter_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68894,7 +68894,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_undefine_reported( +@@ -68969,7 +68969,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( ++int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68980,7 +68980,7 @@ uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68992,7 +68992,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_rms_under_voltage_counter_phc ++ int16_t new_average_rms_under_voltage_counter_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69005,7 +69005,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_undefine_reported( +@@ -69080,7 +69080,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69091,7 +69091,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69103,7 +69103,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_over_voltage_period_phc ++ int16_t new_rms_extreme_over_voltage_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69116,7 +69116,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_undefine_reported( +@@ -69191,7 +69191,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69202,7 +69202,7 @@ uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69214,7 +69214,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_extreme_under_voltage_period_phc ++ int16_t new_rms_extreme_under_voltage_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69227,7 +69227,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_undefine_reported( +@@ -69302,7 +69302,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69313,7 +69313,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69325,7 +69325,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_sag_period_phc ++ int16_t new_rms_voltage_sag_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69338,7 +69338,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_phc_undefine_reported( +@@ -69413,7 +69413,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phc( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( ++int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69424,7 +69424,7 @@ uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69436,7 +69436,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_rms_voltage_swell_period_phc ++ int16_t new_rms_voltage_swell_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69449,7 +69449,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period_phc, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_phc_undefine_reported( +@@ -70005,7 +70005,7 @@ bool dotdot_is_supported_diagnostics_number_of_resets( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_number_of_resets( ++int16_t dotdot_get_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70016,7 +70016,7 @@ uint16_t dotdot_get_diagnostics_number_of_resets( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70028,7 +70028,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_number_of_resets ++ int16_t new_number_of_resets + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70041,7 +70041,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_resets, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_number_of_resets_undefine_reported( +@@ -70116,7 +70116,7 @@ bool dotdot_is_supported_diagnostics_persistent_memory_writes( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_persistent_memory_writes( ++int16_t dotdot_get_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70127,7 +70127,7 @@ uint16_t dotdot_get_diagnostics_persistent_memory_writes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70139,7 +70139,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_persistent_memory_writes ++ int16_t new_persistent_memory_writes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70152,7 +70152,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_persistent_memory_writes, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_persistent_memory_writes_undefine_reported( +@@ -70227,7 +70227,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_bcast( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_diagnostics_mac_rx_bcast( ++int32_t dotdot_get_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70238,7 +70238,7 @@ uint32_t dotdot_get_diagnostics_mac_rx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70250,7 +70250,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_rx_bcast ++ int32_t new_mac_rx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70263,7 +70263,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_rx_bcast, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_diagnostics_mac_rx_bcast_undefine_reported( +@@ -70338,7 +70338,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_bcast( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_diagnostics_mac_tx_bcast( ++int32_t dotdot_get_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70349,7 +70349,7 @@ uint32_t dotdot_get_diagnostics_mac_tx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70361,7 +70361,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_tx_bcast ++ int32_t new_mac_tx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70374,7 +70374,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_bcast, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_bcast_undefine_reported( +@@ -70449,7 +70449,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_ucast( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_diagnostics_mac_rx_ucast( ++int32_t dotdot_get_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70460,7 +70460,7 @@ uint32_t dotdot_get_diagnostics_mac_rx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70472,7 +70472,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_rx_ucast ++ int32_t new_mac_rx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70485,7 +70485,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_rx_ucast, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_diagnostics_mac_rx_ucast_undefine_reported( +@@ -70560,7 +70560,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_diagnostics_mac_tx_ucast( ++int32_t dotdot_get_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70571,7 +70571,7 @@ uint32_t dotdot_get_diagnostics_mac_tx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70583,7 +70583,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mac_tx_ucast ++ int32_t new_mac_tx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70596,7 +70596,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_undefine_reported( +@@ -70671,7 +70671,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_retry( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_mac_tx_ucast_retry( ++int16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70682,7 +70682,7 @@ uint16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70694,7 +70694,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mac_tx_ucast_retry ++ int16_t new_mac_tx_ucast_retry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70707,7 +70707,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast_retry, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_retry_undefine_reported( +@@ -70782,7 +70782,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_fail( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_mac_tx_ucast_fail( ++int16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70793,7 +70793,7 @@ uint16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70805,7 +70805,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_mac_tx_ucast_fail ++ int16_t new_mac_tx_ucast_fail + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70818,7 +70818,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast_fail, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_fail_undefine_reported( +@@ -70893,7 +70893,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_bcast( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_rx_bcast( ++int16_t dotdot_get_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70904,7 +70904,7 @@ uint16_t dotdot_get_diagnostics_aps_rx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70916,7 +70916,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_rx_bcast ++ int16_t new_aps_rx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70929,7 +70929,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_rx_bcast, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_rx_bcast_undefine_reported( +@@ -71004,7 +71004,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_bcast( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_tx_bcast( ++int16_t dotdot_get_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71015,7 +71015,7 @@ uint16_t dotdot_get_diagnostics_aps_tx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71027,7 +71027,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_bcast ++ int16_t new_aps_tx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71040,7 +71040,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_bcast, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_bcast_undefine_reported( +@@ -71115,7 +71115,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_ucast( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_rx_ucast( ++int16_t dotdot_get_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71126,7 +71126,7 @@ uint16_t dotdot_get_diagnostics_aps_rx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71138,7 +71138,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_rx_ucast ++ int16_t new_aps_rx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71151,7 +71151,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_rx_ucast, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_rx_ucast_undefine_reported( +@@ -71226,7 +71226,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_success( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_success( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71237,7 +71237,7 @@ uint16_t dotdot_get_diagnostics_aps_tx_ucast_success( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71249,7 +71249,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_success ++ int16_t new_aps_tx_ucast_success + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71262,7 +71262,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_success, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_success_undefine_reported( +@@ -71337,7 +71337,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_retry( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_retry( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71348,7 +71348,7 @@ uint16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71360,7 +71360,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_retry ++ int16_t new_aps_tx_ucast_retry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71373,7 +71373,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_retry, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_retry_undefine_reported( +@@ -71448,7 +71448,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_fail( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_tx_ucast_fail( ++int16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71459,7 +71459,7 @@ uint16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71471,7 +71471,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_tx_ucast_fail ++ int16_t new_aps_tx_ucast_fail + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71484,7 +71484,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_fail, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_fail_undefine_reported( +@@ -71559,7 +71559,7 @@ bool dotdot_is_supported_diagnostics_route_disc_initiated( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_route_disc_initiated( ++int16_t dotdot_get_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71570,7 +71570,7 @@ uint16_t dotdot_get_diagnostics_route_disc_initiated( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71582,7 +71582,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_route_disc_initiated ++ int16_t new_route_disc_initiated + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71595,7 +71595,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_route_disc_initiated, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_route_disc_initiated_undefine_reported( +@@ -71670,7 +71670,7 @@ bool dotdot_is_supported_diagnostics_neighbor_added( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_neighbor_added( ++int16_t dotdot_get_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71681,7 +71681,7 @@ uint16_t dotdot_get_diagnostics_neighbor_added( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71693,7 +71693,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_added ++ int16_t new_neighbor_added + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71706,7 +71706,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_added, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_added_undefine_reported( +@@ -71781,7 +71781,7 @@ bool dotdot_is_supported_diagnostics_neighbor_removed( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_neighbor_removed( ++int16_t dotdot_get_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71792,7 +71792,7 @@ uint16_t dotdot_get_diagnostics_neighbor_removed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71804,7 +71804,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_removed ++ int16_t new_neighbor_removed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71817,7 +71817,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_removed, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_removed_undefine_reported( +@@ -71892,7 +71892,7 @@ bool dotdot_is_supported_diagnostics_neighbor_stale( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_neighbor_stale( ++int16_t dotdot_get_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71903,7 +71903,7 @@ uint16_t dotdot_get_diagnostics_neighbor_stale( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71915,7 +71915,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_neighbor_stale ++ int16_t new_neighbor_stale + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71928,7 +71928,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_stale, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_stale_undefine_reported( +@@ -72003,7 +72003,7 @@ bool dotdot_is_supported_diagnostics_join_indication( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_join_indication( ++int16_t dotdot_get_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72014,7 +72014,7 @@ uint16_t dotdot_get_diagnostics_join_indication( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72026,7 +72026,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_join_indication ++ int16_t new_join_indication + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72039,7 +72039,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_join_indication, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_join_indication_undefine_reported( +@@ -72114,7 +72114,7 @@ bool dotdot_is_supported_diagnostics_child_moved( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_child_moved( ++int16_t dotdot_get_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72125,7 +72125,7 @@ uint16_t dotdot_get_diagnostics_child_moved( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72137,7 +72137,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_child_moved ++ int16_t new_child_moved + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72150,7 +72150,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_child_moved, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_child_moved_undefine_reported( +@@ -72225,7 +72225,7 @@ bool dotdot_is_supported_diagnostics_nwkfc_failure( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_nwkfc_failure( ++int16_t dotdot_get_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72236,7 +72236,7 @@ uint16_t dotdot_get_diagnostics_nwkfc_failure( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72248,7 +72248,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_nwkfc_failure ++ int16_t new_nwkfc_failure + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72261,7 +72261,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_nwkfc_failure, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_nwkfc_failure_undefine_reported( +@@ -72336,7 +72336,7 @@ bool dotdot_is_supported_diagnostics_apsfc_failure( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_apsfc_failure( ++int16_t dotdot_get_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72347,7 +72347,7 @@ uint16_t dotdot_get_diagnostics_apsfc_failure( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72359,7 +72359,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_apsfc_failure ++ int16_t new_apsfc_failure + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72372,7 +72372,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apsfc_failure, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_apsfc_failure_undefine_reported( +@@ -72447,7 +72447,7 @@ bool dotdot_is_supported_diagnostics_aps_unauthorized_key( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_unauthorized_key( ++int16_t dotdot_get_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72458,7 +72458,7 @@ uint16_t dotdot_get_diagnostics_aps_unauthorized_key( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72470,7 +72470,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_unauthorized_key ++ int16_t new_aps_unauthorized_key + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72483,7 +72483,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_unauthorized_key, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_unauthorized_key_undefine_reported( +@@ -72558,7 +72558,7 @@ bool dotdot_is_supported_diagnostics_nwk_decrypt_failures( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_nwk_decrypt_failures( ++int16_t dotdot_get_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72569,7 +72569,7 @@ uint16_t dotdot_get_diagnostics_nwk_decrypt_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72581,7 +72581,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_nwk_decrypt_failures ++ int16_t new_nwk_decrypt_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72594,7 +72594,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_nwk_decrypt_failures, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_nwk_decrypt_failures_undefine_reported( +@@ -72669,7 +72669,7 @@ bool dotdot_is_supported_diagnostics_aps_decrypt_failures( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_aps_decrypt_failures( ++int16_t dotdot_get_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72680,7 +72680,7 @@ uint16_t dotdot_get_diagnostics_aps_decrypt_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72692,7 +72692,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_aps_decrypt_failures ++ int16_t new_aps_decrypt_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72705,7 +72705,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_decrypt_failures, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_aps_decrypt_failures_undefine_reported( +@@ -72780,7 +72780,7 @@ bool dotdot_is_supported_diagnostics_packet_buffer_allocate_failures( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( ++int16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72791,7 +72791,7 @@ uint16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72803,7 +72803,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_packet_buffer_allocate_failures ++ int16_t new_packet_buffer_allocate_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72816,7 +72816,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_packet_buffer_allocate_failures, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_packet_buffer_allocate_failures_undefine_reported( +@@ -72891,7 +72891,7 @@ bool dotdot_is_supported_diagnostics_relayed_ucast( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_relayed_ucast( ++int16_t dotdot_get_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72902,7 +72902,7 @@ uint16_t dotdot_get_diagnostics_relayed_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72914,7 +72914,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_relayed_ucast ++ int16_t new_relayed_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72927,7 +72927,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_relayed_ucast, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_relayed_ucast_undefine_reported( +@@ -73002,7 +73002,7 @@ bool dotdot_is_supported_diagnostics_phy_to_mac_queue_limit_reached( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( ++int16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73013,7 +73013,7 @@ uint16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73025,7 +73025,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_phy_to_mac_queue_limit_reached ++ int16_t new_phy_to_mac_queue_limit_reached + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73038,7 +73038,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_phy_to_mac_queue_limit_reached, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_phy_to_mac_queue_limit_reached_undefine_reported( +@@ -73113,7 +73113,7 @@ bool dotdot_is_supported_diagnostics_packet_validate_drop_count( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_packet_validate_drop_count( ++int16_t dotdot_get_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73124,7 +73124,7 @@ uint16_t dotdot_get_diagnostics_packet_validate_drop_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73136,7 +73136,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_packet_validate_drop_count ++ int16_t new_packet_validate_drop_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73149,7 +73149,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_packet_validate_drop_count, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_packet_validate_drop_count_undefine_reported( +@@ -73224,7 +73224,7 @@ bool dotdot_is_supported_diagnostics_average_mac_retry_per_aps_message_sent( + return attribute_store_node_exists(node); + } + +-uint16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( ++int16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73235,7 +73235,7 @@ uint16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT); + +- uint16_t result = {}; ++ int16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73247,7 +73247,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint16_t new_average_mac_retry_per_aps_message_sent ++ int16_t new_average_mac_retry_per_aps_message_sent + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73260,7 +73260,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_mac_retry_per_aps_message_sent, +- sizeof(uint16_t)); ++ sizeof(int16_t)); + } + + sl_status_t dotdot_diagnostics_average_mac_retry_per_aps_message_sent_undefine_reported( +@@ -73335,7 +73335,7 @@ bool dotdot_is_supported_diagnostics_last_messagelqi( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_diagnostics_last_messagelqi( ++int8_t dotdot_get_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73346,7 +73346,7 @@ uint8_t dotdot_get_diagnostics_last_messagelqi( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73358,7 +73358,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_last_messagelqi ++ int8_t new_last_messagelqi + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73371,7 +73371,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_last_messagelqi, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_diagnostics_last_messagelqi_undefine_reported( +@@ -73925,7 +73925,7 @@ bool dotdot_is_supported_state_endpoint_id_list( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_state_endpoint_id_list( ++int8_t dotdot_get_state_endpoint_id_list( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73936,7 +73936,7 @@ uint8_t dotdot_get_state_endpoint_id_list( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_STATE_ENDPOINT_ID_LIST); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73949,7 +73949,7 @@ sl_status_t dotdot_set_state_endpoint_id_list( + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, + size_t new_endpoint_id_list_count, +- const uint8_t* new_endpoint_id_list ++ const int8_t* new_endpoint_id_list + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74261,7 +74261,7 @@ bool dotdot_is_supported_state_maximum_command_delay( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_state_maximum_command_delay( ++int32_t dotdot_get_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -74272,7 +74272,7 @@ uint32_t dotdot_get_state_maximum_command_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -74284,7 +74284,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_maximum_command_delay ++ int32_t new_maximum_command_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74297,7 +74297,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_maximum_command_delay, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_state_maximum_command_delay_undefine_reported( +@@ -74887,7 +74887,7 @@ bool dotdot_is_supported_system_metrics_reporting_interval_seconds( + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_system_metrics_reporting_interval_seconds( ++int32_t dotdot_get_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -74898,7 +74898,7 @@ uint32_t dotdot_get_system_metrics_reporting_interval_seconds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -74910,7 +74910,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_reporting_interval_seconds ++ int32_t new_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74923,7 +74923,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_reporting_interval_seconds, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_system_metrics_reporting_interval_seconds_undefine_reported( +@@ -77025,7 +77025,7 @@ bool dotdot_is_supported_system_metrics_uptime_minutes( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_system_metrics_uptime_minutes( ++int64_t dotdot_get_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -77036,7 +77036,7 @@ uint64_t dotdot_get_system_metrics_uptime_minutes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -77048,7 +77048,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_uptime_minutes ++ int64_t new_uptime_minutes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -77061,7 +77061,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_uptime_minutes, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_system_metrics_uptime_minutes_undefine_reported( +@@ -77802,7 +77802,7 @@ bool dotdot_is_supported_system_metrics_system_interrupts( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_system_metrics_system_interrupts( ++int64_t dotdot_get_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -77813,7 +77813,7 @@ uint64_t dotdot_get_system_metrics_system_interrupts( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -77825,7 +77825,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_system_interrupts ++ int64_t new_system_interrupts + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -77838,7 +77838,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_system_interrupts, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_system_metrics_system_interrupts_undefine_reported( +@@ -78465,7 +78465,7 @@ bool dotdot_is_supported_application_monitoring_uptime_minutes( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_application_monitoring_uptime_minutes( ++int64_t dotdot_get_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -78476,7 +78476,7 @@ uint64_t dotdot_get_application_monitoring_uptime_minutes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -78488,7 +78488,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_uptime_minutes ++ int64_t new_uptime_minutes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -78501,7 +78501,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_uptime_minutes, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_application_monitoring_uptime_minutes_undefine_reported( +@@ -78576,7 +78576,7 @@ bool dotdot_is_supported_application_monitoring_process_id( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_application_monitoring_process_id( ++int64_t dotdot_get_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -78587,7 +78587,7 @@ uint64_t dotdot_get_application_monitoring_process_id( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -78599,7 +78599,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_process_id ++ int64_t new_process_id + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -78612,7 +78612,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_process_id, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_application_monitoring_process_id_undefine_reported( +@@ -79133,7 +79133,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_statistics_reporting_interv + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( ++int32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79144,7 +79144,7 @@ uint32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_se + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79156,7 +79156,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_mqtt_statistics_reporting_interval_seconds ++ int32_t new_mqtt_statistics_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79169,7 +79169,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_statistics_reporting_interval_seconds, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_undefine_reported( +@@ -79244,7 +79244,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_sent( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_application_monitoring_mqtt_messages_sent( ++int64_t dotdot_get_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79255,7 +79255,7 @@ uint64_t dotdot_get_application_monitoring_mqtt_messages_sent( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79267,7 +79267,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_messages_sent ++ int64_t new_mqtt_messages_sent + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79280,7 +79280,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_messages_sent, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_messages_sent_undefine_reported( +@@ -79355,7 +79355,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_received( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_application_monitoring_mqtt_messages_received( ++int64_t dotdot_get_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79366,7 +79366,7 @@ uint64_t dotdot_get_application_monitoring_mqtt_messages_received( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79378,7 +79378,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_messages_received ++ int64_t new_mqtt_messages_received + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79391,7 +79391,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_messages_received, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_messages_received_undefine_reported( +@@ -79466,7 +79466,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_subscription_count( + return attribute_store_node_exists(node); + } + +-uint64_t dotdot_get_application_monitoring_mqtt_subscription_count( ++int64_t dotdot_get_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79477,7 +79477,7 @@ uint64_t dotdot_get_application_monitoring_mqtt_subscription_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT); + +- uint64_t result = {}; ++ int64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79489,7 +79489,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint64_t new_mqtt_subscription_count ++ int64_t new_mqtt_subscription_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79502,7 +79502,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_subscription_count, +- sizeof(uint64_t)); ++ sizeof(int64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_subscription_count_undefine_reported( +@@ -79910,7 +79910,7 @@ bool dotdot_is_supported_application_monitoring_application_statistics_reporting + return attribute_store_node_exists(node); + } + +-uint32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( ++int32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79921,7 +79921,7 @@ uint32_t dotdot_get_application_monitoring_application_statistics_reporting_inte + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS); + +- uint32_t result = {}; ++ int32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79933,7 +79933,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint32_t new_application_statistics_reporting_interval_seconds ++ int32_t new_application_statistics_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79946,7 +79946,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_application_statistics_reporting_interval_seconds, +- sizeof(uint32_t)); ++ sizeof(int32_t)); + } + + sl_status_t dotdot_application_monitoring_application_statistics_reporting_interval_seconds_undefine_reported( +@@ -81051,6 +81051,938 @@ bool dotdot_is_any_configuration_parameters_writable_attribute_supported( + const dotdot_endpoint_id_t endpoint_id) { + + ++ return false; ++} ++//////////////////////////////////////////////////////////////////////////////// ++// Start of cluster UserCredential ++//////////////////////////////////////////////////////////////////////////////// ++bool dotdot_is_supported_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ return attribute_store_node_exists(node); ++} ++ ++int16_t dotdot_get_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ ++ int16_t result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ int16_t new_supported_user_unique_identifiers ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_supported_user_unique_identifiers, ++ sizeof(int16_t)); ++ } ++ ++sl_status_t dotdot_user_credential_supported_user_unique_identifiers_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_supported_user_unique_identifiers_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_supported_user_unique_identifiers_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_supported_user_unique_identifiers_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_supported_user_unique_identifiers( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ return attribute_store_node_exists(node); ++} ++ ++uint8_t dotdot_get_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ ++ uint8_t result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint8_t new_supported_credential_rules ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_supported_credential_rules, ++ sizeof(uint8_t)); ++ } ++ ++sl_status_t dotdot_user_credential_supported_credential_rules_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_supported_credential_rules_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_supported_credential_rules_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_supported_credential_rules_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_supported_credential_rules( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ return attribute_store_node_exists(node); ++} ++ ++uint16_t dotdot_get_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ ++ uint16_t result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint16_t new_supported_credential_types ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_supported_credential_types, ++ sizeof(uint16_t)); ++ } ++ ++sl_status_t dotdot_user_credential_supported_credential_types_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_supported_credential_types_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_supported_credential_types_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_supported_credential_types_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_supported_credential_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_supported_user_types( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ return attribute_store_node_exists(node); ++} ++ ++uint16_t dotdot_get_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ ++ uint16_t result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ uint16_t new_supported_user_types ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_supported_user_types, ++ sizeof(uint16_t)); ++ } ++ ++sl_status_t dotdot_user_credential_supported_user_types_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_supported_user_types_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_supported_user_types_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_supported_user_types_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_supported_user_types( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ return attribute_store_node_exists(node); ++} ++ ++bool dotdot_get_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ ++ bool result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_credential_checksum ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_support_credential_checksum, ++ sizeof(bool)); ++ } ++ ++sl_status_t dotdot_user_credential_support_credential_checksum_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_support_credential_checksum_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_support_credential_checksum_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_support_credential_checksum_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_support_credential_checksum( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ return attribute_store_node_exists(node); ++} ++ ++bool dotdot_get_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ ++ bool result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_admin_pin_code ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_support_admin_pin_code, ++ sizeof(bool)); ++ } ++ ++sl_status_t dotdot_user_credential_support_admin_pin_code_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_support_admin_pin_code_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_support_admin_pin_code_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_support_admin_pin_code_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_support_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ return attribute_store_node_exists(node); ++} ++ ++bool dotdot_get_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ ++ bool result = {}; ++ attribute_store_read_value(node, ++ value_state, ++ (uint8_t *)&result, ++ sizeof(result)); ++ return result; ++} ++ ++sl_status_t dotdot_set_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ bool new_support_admin_pin_code_deactivation ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ ++ return attribute_store_set_node_attribute_value(node, ++ value_state, ++ (uint8_t *)&new_support_admin_pin_code_deactivation, ++ sizeof(bool)); ++ } ++ ++sl_status_t dotdot_user_credential_support_admin_pin_code_deactivation_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_support_admin_pin_code_deactivation_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_support_admin_pin_code_deactivation_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_support_admin_pin_code_deactivation_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_support_admin_pin_code_deactivation( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++bool dotdot_is_supported_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ return attribute_store_node_exists(node); ++} ++ ++const char* dotdot_get_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ ++ if (REPORTED_ATTRIBUTE == value_state) { ++ attribute_store_get_reported_string(node, received_string, ATTRIBUTE_STORE_MAXIMUM_VALUE_LENGTH); ++ } else { ++ attribute_store_get_desired_string(node, received_string, ATTRIBUTE_STORE_MAXIMUM_VALUE_LENGTH); ++ } ++ return received_string; ++} ++ ++sl_status_t dotdot_set_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ attribute_store_node_value_state_t value_state, ++ const char* new_admin_pin_code ++ ) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ ++ if (REPORTED_ATTRIBUTE == value_state){ ++ return attribute_store_set_reported_string(node, new_admin_pin_code); ++ } else { ++ return attribute_store_set_desired_string(node, new_admin_pin_code); ++ } ++} ++ ++sl_status_t dotdot_user_credential_admin_pin_code_undefine_reported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ attribute_store_undefine_reported(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++sl_status_t dotdot_user_credential_admin_pin_code_undefine_desired( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ attribute_store_undefine_desired(node); ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++ ++bool dotdot_user_credential_admin_pin_code_is_reported_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ return attribute_store_is_reported_defined(node); ++} ++ ++bool dotdot_user_credential_admin_pin_code_is_desired_defined( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) ++{ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node ++ = attribute_store_get_first_child_by_type( ++ endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ return attribute_store_is_desired_defined(node); ++} ++ ++sl_status_t dotdot_create_user_credential_admin_pin_code( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); ++ attribute_store_node_t node = ++ attribute_store_create_child_if_missing(endpoint_node, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE); ++ ++ return (node != ATTRIBUTE_STORE_INVALID_NODE) ? SL_STATUS_OK : SL_STATUS_FAIL; ++} ++ ++bool dotdot_is_any_user_credential_attribute_supported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ if (true == dotdot_is_supported_user_credential_supported_user_unique_identifiers(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_supported_credential_rules(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_supported_credential_types(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_supported_user_types(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_support_credential_checksum(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_support_admin_pin_code(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_support_admin_pin_code_deactivation(unid, endpoint_id)) { ++ return true; ++ } ++ if (true == dotdot_is_supported_user_credential_admin_pin_code(unid, endpoint_id)) { ++ return true; ++ } ++ ++ return false; ++} ++ ++bool dotdot_is_any_user_credential_writable_attribute_supported( ++ const dotdot_unid_t unid, ++ const dotdot_endpoint_id_t endpoint_id) { ++ ++ + return false; + } + //////////////////////////////////////////////////////////////////////////////// +@@ -82954,7 +83886,7 @@ bool dotdot_is_supported_unify_humidity_control_humidifier_setpoint_precision( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -82965,7 +83897,7 @@ uint8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -82977,7 +83909,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_humidifier_setpoint_precision ++ int8_t new_humidifier_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -82990,7 +83922,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_humidifier_setpoint_precision, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_unify_humidity_control_humidifier_setpoint_precision_undefine_reported( +@@ -83509,7 +84441,7 @@ bool dotdot_is_supported_unify_humidity_control_dehumidifier_setpoint_precision( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -83520,7 +84452,7 @@ uint8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -83532,7 +84464,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_dehumidifier_setpoint_precision ++ int8_t new_dehumidifier_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -83545,7 +84477,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidifier_setpoint_precision, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_unify_humidity_control_dehumidifier_setpoint_precision_undefine_reported( +@@ -84064,7 +84996,7 @@ bool dotdot_is_supported_unify_humidity_control_auto_setpoint_precision( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( ++int8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -84075,7 +85007,7 @@ uint8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION); + +- uint8_t result = {}; ++ int8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -84087,7 +85019,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_auto_setpoint_precision ++ int8_t new_auto_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -84100,7 +85032,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_auto_setpoint_precision, +- sizeof(uint8_t)); ++ sizeof(int8_t)); + } + + sl_status_t dotdot_unify_humidity_control_auto_setpoint_precision_undefine_reported( +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp +index a321941cf6..414f77fe8a 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp +@@ -104,8 +104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -114,7 +114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ZCLVersion, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -128,8 +128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -138,7 +138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ApplicationVersion, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -152,8 +152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -162,7 +162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic StackVersion, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -176,8 +176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -186,7 +186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic HWVersion, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -344,8 +344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // const char* +- std::string attribute_type_string = "const char*"; ++ // octstr // octstr // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -354,7 +354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ProductCode, " +- "type: octstr // const char*"); ++ "type: octstr // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -608,8 +608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -618,7 +618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltage, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -632,8 +632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -642,7 +642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsFrequency, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -680,8 +680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -690,7 +690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageMinThreshold, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -704,8 +704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -714,7 +714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageMaxThreshold, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -728,8 +728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -738,7 +738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageDwellTripPoint, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -752,8 +752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -762,7 +762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -776,8 +776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -786,7 +786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageRemaining, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -848,8 +848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -858,7 +858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryAHrRating, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -872,8 +872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -882,7 +882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryQuantity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -896,8 +896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -906,7 +906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryRatedVoltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -944,8 +944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -954,7 +954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -968,8 +968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -978,7 +978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -992,8 +992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1002,7 +1002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1016,8 +1016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1026,7 +1026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1040,8 +1040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1050,7 +1050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1064,8 +1064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1074,7 +1074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1088,8 +1088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1098,7 +1098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1112,8 +1112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1122,7 +1122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1160,8 +1160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1170,7 +1170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2Voltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1184,8 +1184,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1194,7 +1194,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageRemaining, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1256,8 +1256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1266,7 +1266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2AHrRating, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -1280,8 +1280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1290,7 +1290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2Quantity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1304,8 +1304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1314,7 +1314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2RatedVoltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1352,8 +1352,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1362,7 +1362,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1376,8 +1376,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1386,7 +1386,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1400,8 +1400,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1410,7 +1410,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1424,8 +1424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1434,7 +1434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1448,8 +1448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1458,7 +1458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1472,8 +1472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1482,7 +1482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1496,8 +1496,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1506,7 +1506,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1520,8 +1520,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1530,7 +1530,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1568,8 +1568,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1578,7 +1578,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3Voltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1592,8 +1592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1602,7 +1602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageRemaining, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1664,8 +1664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1674,7 +1674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3AHrRating, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -1688,8 +1688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1698,7 +1698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3Quantity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1712,8 +1712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1722,7 +1722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3RatedVoltage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1760,8 +1760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1770,7 +1770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1784,8 +1784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1794,7 +1794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1808,8 +1808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1818,7 +1818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1832,8 +1832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1842,7 +1842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1856,8 +1856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1866,7 +1866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageMinThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1880,8 +1880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1890,7 +1890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold1, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1904,8 +1904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1914,7 +1914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold2, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -1928,8 +1928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1938,7 +1938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold3, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2048,8 +2048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2058,7 +2058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration OverTempTotalDwell, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2144,8 +2144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2154,7 +2154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration LowTempDwellTripPoint, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -2168,8 +2168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2178,7 +2178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration HighTempDwellTripPoint, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -2192,8 +2192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2202,7 +2202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Identify IdentifyTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2240,8 +2240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2250,7 +2250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes SceneCount, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2264,8 +2264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2274,7 +2274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes CurrentScene, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2288,8 +2288,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // SGroupId // SGroupId // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // SGroupId // SGroupId // uint8_t * ++ std::string attribute_type_string = "uint8_t *"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2298,7 +2298,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes CurrentGroup, " +- "type: SGroupId // uint16_t"); ++ "type: SGroupId // uint8_t *"); + } + + status |= attribute_store_register_type( +@@ -2456,8 +2456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2466,7 +2466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OnOff OnTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2480,8 +2480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2490,7 +2490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OnOff OffWaitTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2528,8 +2528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2538,7 +2538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level CurrentLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2552,8 +2552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2562,7 +2562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level RemainingTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2576,8 +2576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2586,7 +2586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MinLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2600,8 +2600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2610,7 +2610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MaxLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2624,8 +2624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2634,7 +2634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level CurrentFrequency, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2648,8 +2648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2658,7 +2658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MinFrequency, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2672,8 +2672,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2682,7 +2682,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MaxFrequency, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2720,8 +2720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2730,7 +2730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnOffTransitionTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2744,8 +2744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2754,7 +2754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2768,8 +2768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2778,7 +2778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnTransitionTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2792,8 +2792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2802,7 +2802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OffTransitionTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2816,8 +2816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2826,7 +2826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level DefaultMoveRate, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2840,8 +2840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2850,7 +2850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level StartUpCurrentLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -2864,8 +2864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2874,7 +2874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Alarms AlarmCount, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -2888,8 +2888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2898,7 +2898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time Time, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2960,8 +2960,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2970,7 +2970,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time DstStart, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -2984,8 +2984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2994,7 +2994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time DstEnd, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3032,8 +3032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3042,7 +3042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time StandardTime, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3056,8 +3056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3066,7 +3066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time LocalTime, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3080,8 +3080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3090,7 +3090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time LastSetTime, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3104,8 +3104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3114,7 +3114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time ValidUntilTime, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3128,8 +3128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3138,7 +3138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl CheckInInterval, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3152,8 +3152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3162,7 +3162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl LongPollInterval, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3176,8 +3176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3186,7 +3186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl ShortPollInterval, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3200,8 +3200,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3210,7 +3210,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl FastPollTimeout, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3224,8 +3224,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3234,7 +3234,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl CheckInIntervalMin, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3248,8 +3248,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3258,7 +3258,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl LongPollIntervalMin, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3272,8 +3272,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3282,7 +3282,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl FastPollTimeoutMax, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3296,8 +3296,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3306,7 +3306,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration PhysicalClosedLimit, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3320,8 +3320,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3330,7 +3330,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration MotorStepSize, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3368,8 +3368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3378,7 +3378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration ClosedLimit, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3512,8 +3512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3522,7 +3522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock DoorOpenEvents, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3536,8 +3536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3546,7 +3546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock DoorClosedEvents, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3560,8 +3560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3570,7 +3570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock OpenPeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3584,8 +3584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3594,7 +3594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfLogRecordsSupported, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3608,8 +3608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3618,7 +3618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfTotalUsersSupported, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3632,8 +3632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3642,7 +3642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfPINUsersSupported, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3656,8 +3656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3666,7 +3666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfRFIDUsersSupported, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -3680,8 +3680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3690,7 +3690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfWeekDaySchedulesSupportedPerUser, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3704,8 +3704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3714,7 +3714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfYearDaySchedulesSupportedPerUser, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3728,8 +3728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3738,7 +3738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfHolidaySchedulesSupported, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3752,8 +3752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3762,7 +3762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MaxPINCodeLength, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3776,8 +3776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3786,7 +3786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MinPINCodeLength, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3800,8 +3800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3810,7 +3810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MaxRFIDCodeLength, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3824,8 +3824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3834,7 +3834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MinRFIDCodeLength, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3872,8 +3872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3882,7 +3882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfCredentialsSupportedPerUser, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3944,8 +3944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3954,7 +3954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock LEDSettings, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -3968,8 +3968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3978,7 +3978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock AutoRelockTime, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -3992,8 +3992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4002,7 +4002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock SoundVolume, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -4208,8 +4208,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4218,7 +4218,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock WrongCodeEntryLimit, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -4232,8 +4232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4242,7 +4242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock UserCodeTemporaryDisableTime, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -4328,8 +4328,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4338,7 +4338,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock ExpiringUserTimeout, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4592,8 +4592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4602,7 +4602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering PhysicalClosedLimitLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4616,8 +4616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4626,7 +4626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering PhysicalClosedLimitTilt, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4640,8 +4640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4650,7 +4650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4664,8 +4664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4674,7 +4674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionTilt, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4688,8 +4688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4698,7 +4698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering NumberOfActuationsLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4712,8 +4712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4722,7 +4722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering NumberOfActuationsTilt, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4760,8 +4760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4770,7 +4770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionLiftPercentage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -4784,8 +4784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4794,7 +4794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionTiltPercentage, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -4808,8 +4808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4818,7 +4818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledOpenLimitLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4832,8 +4832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4842,7 +4842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledClosedLimitLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4856,8 +4856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4866,7 +4866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledOpenLimitTilt, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4880,8 +4880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4890,7 +4890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledClosedLimitTilt, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4904,8 +4904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4914,7 +4914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering VelocityLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4928,8 +4928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4938,7 +4938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering AccelerationTimeLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -4952,8 +4952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4962,7 +4962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering DecelerationTimeLift, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5000,8 +5000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // const char* +- std::string attribute_type_string = "const char*"; ++ // octstr // octstr // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5010,7 +5010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering IntermediateSetpointsLift, " +- "type: octstr // const char*"); ++ "type: octstr // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -5024,8 +5024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // const char* +- std::string attribute_type_string = "const char*"; ++ // octstr // octstr // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5034,7 +5034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering IntermediateSetpointsTilt, " +- "type: octstr // const char*"); ++ "type: octstr // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -5120,8 +5120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5130,7 +5130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl OpenEvents, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5144,8 +5144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5154,7 +5154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CloseEvents, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5168,8 +5168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5178,7 +5178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CommandOpenEvents, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5192,8 +5192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5202,7 +5202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CommandCloseEvents, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5216,8 +5216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5226,7 +5226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl OpenPeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5240,8 +5240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5250,7 +5250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl ClosePeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5264,8 +5264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5274,7 +5274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl BarrierPosition, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -5312,8 +5312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5322,7 +5322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxSpeed, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5336,8 +5336,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5346,7 +5346,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxFlow, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5456,8 +5456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5466,7 +5466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MinConstSpeed, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5480,8 +5480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5490,7 +5490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxConstSpeed, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5504,8 +5504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5514,7 +5514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MinConstFlow, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5528,8 +5528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5538,7 +5538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxConstFlow, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5696,8 +5696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5706,7 +5706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl Speed, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -5720,8 +5720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5730,7 +5730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl LifetimeRunningHours, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -5744,8 +5744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5754,7 +5754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl Power, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -5768,8 +5768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5778,7 +5778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl LifetimeEnergyConsumed, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -6032,8 +6032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6042,7 +6042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat PICoolingDemand, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6056,8 +6056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6066,7 +6066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat PIHeatingDemand, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6488,8 +6488,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6498,7 +6498,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat NumberOfWeeklyTransitions, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6512,8 +6512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6522,7 +6522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat NumberOfDailyTransitions, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6560,8 +6560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6570,7 +6570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat TemperatureSetpointHoldDuration, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -6680,8 +6680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6690,7 +6690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat SetpointChangeSourceTimestamp, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6704,8 +6704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6714,7 +6714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetback, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6728,8 +6728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6738,7 +6738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetbackMin, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6752,8 +6752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6762,7 +6762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetbackMax, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6776,8 +6776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6786,7 +6786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetback, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6800,8 +6800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6810,7 +6810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetbackMin, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6824,8 +6824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6834,7 +6834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetbackMax, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6848,8 +6848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6858,7 +6858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat EmergencyHeatDelta, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -6896,8 +6896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6906,7 +6906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat ACCapacity, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7112,8 +7112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7122,7 +7122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl RelativeHumidity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7136,8 +7136,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7146,7 +7146,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationCooling, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7160,8 +7160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7170,7 +7170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl RHDehumidificationSetpoint, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7232,8 +7232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7242,7 +7242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationHysteresis, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7256,8 +7256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7266,7 +7266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationMaxCool, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7376,8 +7376,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7386,7 +7386,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentHue, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7400,8 +7400,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7410,7 +7410,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentSaturation, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7424,8 +7424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7434,7 +7434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl RemainingTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7448,8 +7448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7458,7 +7458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentX, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7472,8 +7472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7482,7 +7482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentY, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7544,8 +7544,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7554,7 +7554,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTemperatureMireds, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7616,8 +7616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7626,7 +7626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl NumberOfPrimaries, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7640,8 +7640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7650,7 +7650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7664,8 +7664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7674,7 +7674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7688,8 +7688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7698,7 +7698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7712,8 +7712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7722,7 +7722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7736,8 +7736,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7746,7 +7746,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7760,8 +7760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7770,7 +7770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7784,8 +7784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7794,7 +7794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7808,8 +7808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7818,7 +7818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7832,8 +7832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7842,7 +7842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7856,8 +7856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7866,7 +7866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7880,8 +7880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7890,7 +7890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7904,8 +7904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7914,7 +7914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -7928,8 +7928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7938,7 +7938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7952,8 +7952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7962,7 +7962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -7976,8 +7976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7986,7 +7986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8000,8 +8000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8010,7 +8010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6X, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8024,8 +8024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8034,7 +8034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6Y, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8048,8 +8048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8058,7 +8058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6Intensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8072,8 +8072,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8082,7 +8082,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl WhitePointX, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8096,8 +8096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8106,7 +8106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl WhitePointY, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8120,8 +8120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8130,7 +8130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRX, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8144,8 +8144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8154,7 +8154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRY, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8168,8 +8168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8178,7 +8178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRIntensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8192,8 +8192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8202,7 +8202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGX, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8216,8 +8216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8226,7 +8226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGY, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8240,8 +8240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8250,7 +8250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGIntensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8264,8 +8264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8274,7 +8274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBX, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8288,8 +8288,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8298,7 +8298,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBY, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8312,8 +8312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8322,7 +8322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBIntensity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8336,8 +8336,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8346,7 +8346,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl EnhancedCurrentHue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8384,8 +8384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8394,7 +8394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopActive, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8408,8 +8408,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8418,7 +8418,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopDirection, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8432,8 +8432,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8442,7 +8442,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8456,8 +8456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8466,7 +8466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopStartEnhancedHue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8480,8 +8480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8490,7 +8490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopStoredEnhancedHue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8528,8 +8528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8538,7 +8538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTempPhysicalMinMireds, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8552,8 +8552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8562,7 +8562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTempPhysicalMaxMireds, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8576,8 +8576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8586,7 +8586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CoupleColorTempToLevelMinMireds, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8600,8 +8600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8610,7 +8610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl StartUpColorTemperatureMireds, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8624,8 +8624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8634,7 +8634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PhysicalMinLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8648,8 +8648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8658,7 +8658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PhysicalMaxLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8696,8 +8696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8706,7 +8706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration MinLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8720,8 +8720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8730,7 +8730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration MaxLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8744,8 +8744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8754,7 +8754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PowerOnLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8768,8 +8768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8778,7 +8778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PowerOnFadeTime, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -8792,8 +8792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8802,7 +8802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration IntrinsicBallastFactor, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8816,8 +8816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8826,7 +8826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration BallastFactorAdjustment, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8840,8 +8840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8850,7 +8850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampQuantity, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -8912,8 +8912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8922,7 +8922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampRatedHours, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -8936,8 +8936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8946,7 +8946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampBurnHours, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -8984,8 +8984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8994,7 +8994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampBurnHoursTripPoint, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -9008,8 +9008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9018,7 +9018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9032,8 +9032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9042,7 +9042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9056,8 +9056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9066,7 +9066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9080,8 +9080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9090,7 +9090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9176,8 +9176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9186,7 +9186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceLevelSensing IlluminanceTargetLevel, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9272,8 +9272,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9282,7 +9282,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL TemperatureMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9368,8 +9368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9378,7 +9378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PressureMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9464,8 +9464,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9474,7 +9474,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PressureMeasurement ScaledTolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9512,8 +9512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9522,7 +9522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9536,8 +9536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9546,7 +9546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9560,8 +9560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9570,7 +9570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9584,8 +9584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9594,7 +9594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9608,8 +9608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9618,7 +9618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9632,8 +9632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9642,7 +9642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9656,8 +9656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9666,7 +9666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9680,8 +9680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9690,7 +9690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9776,8 +9776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9786,7 +9786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIROccupiedToUnoccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9800,8 +9800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9810,7 +9810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIRUnoccupiedToOccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9824,8 +9824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9834,7 +9834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIRUnoccupiedToOccupiedThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -9848,8 +9848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9858,7 +9858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicOccupiedToUnoccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9872,8 +9872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9882,7 +9882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicUnoccupiedToOccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9896,8 +9896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9906,7 +9906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicUnoccupiedToOccupiedThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -9920,8 +9920,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9930,7 +9930,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactOccupiedToUnoccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9944,8 +9944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9954,7 +9954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactUnoccupiedToOccupiedDelay, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -9968,8 +9968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9978,7 +9978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactUnoccupiedToOccupiedThreshold, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -9992,8 +9992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10002,7 +10002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10016,8 +10016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10026,7 +10026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10040,8 +10040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10050,7 +10050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10064,8 +10064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10074,7 +10074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10088,8 +10088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10098,7 +10098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10112,8 +10112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10122,7 +10122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10136,8 +10136,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10146,7 +10146,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10160,8 +10160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10170,7 +10170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10184,8 +10184,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10194,7 +10194,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10208,8 +10208,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10218,7 +10218,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10232,8 +10232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10242,7 +10242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10256,8 +10256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10266,7 +10266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10280,8 +10280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10290,7 +10290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10304,8 +10304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10314,7 +10314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MinMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10328,8 +10328,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10338,7 +10338,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MaxMeasuredValue, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10352,8 +10352,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10362,7 +10362,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement Tolerance, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10760,8 +10760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10770,7 +10770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone ZoneID, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -10784,8 +10784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10794,7 +10794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone NumberOfZoneSensitivityLevelsSupported, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -10808,8 +10808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10818,7 +10818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone CurrentZoneSensitivityLevel, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -10832,8 +10832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10842,7 +10842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASWD MaxDuration, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -10856,8 +10856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10866,7 +10866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentSummationDelivered, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -10880,8 +10880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10890,7 +10890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentSummationReceived, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -10904,8 +10904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10914,7 +10914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandDelivered, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -10976,8 +10976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10986,7 +10986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering ReadingSnapShotTime, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -11000,8 +11000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11010,7 +11010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandDeliveredTime, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -11024,8 +11024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // UTC // UTC // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11034,7 +11034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandReceivedTime, " +- "type: UTC // uint32_t"); ++ "type: UTC // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -11048,8 +11048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11058,7 +11058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering DefaultUpdatePeriod, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -11096,8 +11096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11106,7 +11106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentInletEnergyCarrierSummation, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -11120,8 +11120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11130,7 +11130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentOutletEnergyCarrierSummation, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -11216,8 +11216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11226,7 +11226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering Multiplier, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -11240,8 +11240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint24 // uint24 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11250,7 +11250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering Divisor, " +- "type: uint24 // uint32_t"); ++ "type: uint24 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -11720,8 +11720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11730,7 +11730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCVoltageMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11744,8 +11744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11754,7 +11754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCVoltageDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11768,8 +11768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11778,7 +11778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCCurrentMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11792,8 +11792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11802,7 +11802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCCurrentDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11816,8 +11816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11826,7 +11826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCPowerMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11840,8 +11840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11850,7 +11850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCPowerDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11864,8 +11864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11874,7 +11874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequency, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11888,8 +11888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11898,7 +11898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMin, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11912,8 +11912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11922,7 +11922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMax, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -11936,8 +11936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11946,7 +11946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement NeutralCurrent, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12008,8 +12008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12018,7 +12018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement TotalApparentPower, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -12320,8 +12320,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12330,7 +12330,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12344,8 +12344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12354,7 +12354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12368,8 +12368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12378,7 +12378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement PowerMultiplier, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -12392,8 +12392,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12402,7 +12402,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement PowerDivisor, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -12464,8 +12464,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12474,7 +12474,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrent, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12536,8 +12536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12546,7 +12546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltage, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12560,8 +12560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12570,7 +12570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMin, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12584,8 +12584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12594,7 +12594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMax, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12608,8 +12608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12618,7 +12618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrent, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12632,8 +12632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12642,7 +12642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMin, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12656,8 +12656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12666,7 +12666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMax, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12776,8 +12776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12786,7 +12786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPower, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12824,8 +12824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12834,7 +12834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12848,8 +12848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12858,7 +12858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounter, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12872,8 +12872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12882,7 +12882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounter, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12896,8 +12896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12906,7 +12906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12920,8 +12920,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12930,7 +12930,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12944,8 +12944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12954,7 +12954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12968,8 +12968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12978,7 +12978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriod, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -12992,8 +12992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13002,7 +13002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACVoltageMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13016,8 +13016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13026,7 +13026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACVoltageDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13040,8 +13040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13050,7 +13050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACCurrentMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13064,8 +13064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13074,7 +13074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACCurrentDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13088,8 +13088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13098,7 +13098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACPowerMultiplier, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13112,8 +13112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13122,7 +13122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACPowerDivisor, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13472,8 +13472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13482,7 +13482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrentPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13544,8 +13544,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13554,7 +13554,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltagePhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13568,8 +13568,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13578,7 +13578,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMinPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13592,8 +13592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13602,7 +13602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMaxPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13616,8 +13616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13626,7 +13626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13640,8 +13640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13650,7 +13650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMinPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13664,8 +13664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13674,7 +13674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMaxPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13784,8 +13784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13794,7 +13794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPowerPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13832,8 +13832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13842,7 +13842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriodPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13856,8 +13856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13866,7 +13866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounterPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13880,8 +13880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13890,7 +13890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounterPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13904,8 +13904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13914,7 +13914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriodPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13928,8 +13928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13938,7 +13938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriodPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13952,8 +13952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13962,7 +13962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriodPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -13976,8 +13976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13986,7 +13986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriodPhB, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14000,8 +14000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14010,7 +14010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrentPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14072,8 +14072,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14082,7 +14082,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltagePhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14096,8 +14096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14106,7 +14106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMinPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14120,8 +14120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14130,7 +14130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMaxPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14144,8 +14144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14154,7 +14154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14168,8 +14168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14178,7 +14178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMinPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14192,8 +14192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14202,7 +14202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMaxPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14312,8 +14312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14322,7 +14322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPowerPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14360,8 +14360,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14370,7 +14370,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriodPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14384,8 +14384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14394,7 +14394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounterPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14408,8 +14408,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14418,7 +14418,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounterPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14432,8 +14432,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14442,7 +14442,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriodPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14456,8 +14456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14466,7 +14466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriodPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14480,8 +14480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14490,7 +14490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriodPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14504,8 +14504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14514,7 +14514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriodPhC, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14528,8 +14528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14538,7 +14538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NumberOfResets, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14552,8 +14552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14562,7 +14562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PersistentMemoryWrites, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14576,8 +14576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14586,7 +14586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacRxBcast, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -14600,8 +14600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14610,7 +14610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxBcast, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -14624,8 +14624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14634,7 +14634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacRxUcast, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -14648,8 +14648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14658,7 +14658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcast, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -14672,8 +14672,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14682,7 +14682,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcastRetry, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14696,8 +14696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14706,7 +14706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcastFail, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14720,8 +14720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14730,7 +14730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSRxBcast, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14744,8 +14744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14754,7 +14754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxBcast, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14768,8 +14768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14778,7 +14778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSRxUcast, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14792,8 +14792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14802,7 +14802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastSuccess, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14816,8 +14816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14826,7 +14826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastRetry, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14840,8 +14840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14850,7 +14850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastFail, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14864,8 +14864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14874,7 +14874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics RouteDiscInitiated, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14888,8 +14888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14898,7 +14898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborAdded, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14912,8 +14912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14922,7 +14922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborRemoved, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14936,8 +14936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14946,7 +14946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborStale, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14960,8 +14960,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14970,7 +14970,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics JoinIndication, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -14984,8 +14984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14994,7 +14994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics ChildMoved, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15008,8 +15008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15018,7 +15018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NWKFCFailure, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15032,8 +15032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15042,7 +15042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSFCFailure, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15056,8 +15056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15066,7 +15066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSUnauthorizedKey, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15080,8 +15080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15090,7 +15090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NWKDecryptFailures, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15104,8 +15104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15114,7 +15114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSDecryptFailures, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15128,8 +15128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15138,7 +15138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PacketBufferAllocateFailures, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15152,8 +15152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15162,7 +15162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics RelayedUcast, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15176,8 +15176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15186,7 +15186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PHYToMACQueueLimitReached, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15200,8 +15200,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15210,7 +15210,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PacketValidateDropCount, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15224,8 +15224,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // uint16_t +- std::string attribute_type_string = "uint16_t"; ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15234,7 +15234,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics AverageMACRetryPerAPSMessageSent, " +- "type: uint16 // uint16_t"); ++ "type: uint16 // int16_t"); + } + + status |= attribute_store_register_type( +@@ -15248,8 +15248,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15258,7 +15258,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics LastMessageLQI, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -15344,8 +15344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15354,7 +15354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL State EndpointIdList, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -15416,8 +15416,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15426,7 +15426,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL State MaximumCommandDelay, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -15536,8 +15536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15546,7 +15546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics ReportingIntervalSeconds, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -15992,8 +15992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16002,7 +16002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics UptimeMinutes, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16160,8 +16160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16170,7 +16170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics SystemInterrupts, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16280,8 +16280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16290,7 +16290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring UptimeMinutes, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16304,8 +16304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16314,7 +16314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring ProcessId, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16424,8 +16424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16434,7 +16434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTStatisticsReportingIntervalSeconds, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -16448,8 +16448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16458,7 +16458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTMessagesSent, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16472,8 +16472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16482,7 +16482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTMessagesReceived, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16496,8 +16496,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // uint64_t +- std::string attribute_type_string = "uint64_t"; ++ // uint64 // uint64 // int64_t ++ std::string attribute_type_string = "int64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16506,7 +16506,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTSubscriptionCount, " +- "type: uint64 // uint64_t"); ++ "type: uint64 // int64_t"); + } + + status |= attribute_store_register_type( +@@ -16592,8 +16592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // uint32_t +- std::string attribute_type_string = "uint32_t"; ++ // uint32 // uint32 // int32_t ++ std::string attribute_type_string = "int32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16602,7 +16602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring ApplicationStatisticsReportingIntervalSeconds, " +- "type: uint32 // uint32_t"); ++ "type: uint32 // int32_t"); + } + + status |= attribute_store_register_type( +@@ -16807,6 +16807,198 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format off + // clang-format on + ++ { ++ // uint16 // uint16 // int16_t ++ std::string attribute_type_string = "int16_t"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportedUserUniqueIdentifiers, " ++ "type: uint16 // int16_t"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS, ++ "ZCL UserCredential SupportedUserUniqueIdentifiers", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // map8 // map8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportedCredentialRules, " ++ "type: map8 // uint8_t"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, ++ "ZCL UserCredential SupportedCredentialRules", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // map16 // map16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportedCredentialTypes, " ++ "type: map16 // uint16_t"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, ++ "ZCL UserCredential SupportedCredentialTypes", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // map16 // map16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportedUserTypes, " ++ "type: map16 // uint16_t"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES, ++ "ZCL UserCredential SupportedUserTypes", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // bool // bool // bool ++ std::string attribute_type_string = "bool"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportCredentialChecksum, " ++ "type: bool // bool"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, ++ "ZCL UserCredential SupportCredentialChecksum", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // bool // bool // bool ++ std::string attribute_type_string = "bool"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportAdminPinCode, " ++ "type: bool // bool"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, ++ "ZCL UserCredential SupportAdminPinCode", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // bool // bool // bool ++ std::string attribute_type_string = "bool"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = attribute_storage_type_conversion(attribute_type_string); ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential SupportAdminPinCodeDeactivation, " ++ "type: bool // bool"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, ++ "ZCL UserCredential SupportAdminPinCodeDeactivation", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ ++ { ++ // string // string // const char* ++ std::string attribute_type_string = "const char*"; ++ attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; ++ ++ // clang-format off ++ storage_type = C_STRING_STORAGE_TYPE; ++ ++ if (storage_type == UNKNOWN_STORAGE_TYPE) { ++ sl_log_warning(LOG_TAG, ++ "Unkown storage type for ZCL UserCredential AdminPinCode, " ++ "type: string // const char*"); ++ } ++ ++ status |= attribute_store_register_type( ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE, ++ "ZCL UserCredential AdminPinCode", ++ ATTRIBUTE_STORE_INVALID_ATTRIBUTE_TYPE, ++ storage_type); ++ } ++ ++ // clang-format off ++ // clang-format on ++ + { + // NetworkManagementState // NetworkManagementState // NetworkManagementState + std::string attribute_type_string = "NetworkManagementState"; +@@ -17192,8 +17384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17202,7 +17394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl HumidifierSetpointPrecision, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -17312,8 +17504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17322,7 +17514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl DehumidifierSetpointPrecision, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +@@ -17432,8 +17624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // uint8 // uint8 // int8_t ++ std::string attribute_type_string = "int8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17442,7 +17634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl AutoSetpointPrecision, " +- "type: uint8 // uint8_t"); ++ "type: uint8 // int8_t"); + } + + status |= attribute_store_register_type( +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_write_attributes_command_callbacks.c b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_write_attributes_command_callbacks.c +index 799780c184..7443995a7b 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_write_attributes_command_callbacks.c ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_write_attributes_command_callbacks.c +@@ -2398,6 +2398,36 @@ static sl_status_t configuration_parameters_cluster_write_attributes_callback( + return SL_STATUS_OK; + } + //////////////////////////////////////////////////////////////////////////////// ++// Start of cluster UserCredential ++//////////////////////////////////////////////////////////////////////////////// ++// WriteAttribute Callbacks user_credential ++static sl_status_t user_credential_cluster_write_attributes_callback( ++ const dotdot_unid_t unid, ++ dotdot_endpoint_id_t endpoint_id, ++ uic_mqtt_dotdot_callback_call_type_t call_type, ++ uic_mqtt_dotdot_user_credential_state_t attributes, ++ uic_mqtt_dotdot_user_credential_updated_state_t updated_attributes) ++{ ++ if (false == is_write_attributes_enabled()) { ++ return SL_STATUS_FAIL; ++ } ++ ++ if (call_type == UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK) { ++ if (is_automatic_deduction_of_supported_commands_enabled()) { ++ return dotdot_is_any_user_credential_writable_attribute_supported(unid, endpoint_id) ? ++ SL_STATUS_OK : SL_STATUS_FAIL; ++ } else { ++ return SL_STATUS_FAIL; ++ } ++ } ++ ++ sl_log_debug(LOG_TAG, ++ "user_credential: Incoming WriteAttributes command for %s, endpoint %d.\n", ++ unid, ++ endpoint_id); ++ return SL_STATUS_OK; ++} ++//////////////////////////////////////////////////////////////////////////////// + // Start of cluster ProtocolController-NetworkManagement + //////////////////////////////////////////////////////////////////////////////// + // WriteAttribute Callbacks protocol_controller_network_management +@@ -2710,6 +2740,9 @@ sl_status_t + uic_mqtt_dotdot_set_configuration_parameters_write_attributes_callback( + &configuration_parameters_cluster_write_attributes_callback); + ++ uic_mqtt_dotdot_set_user_credential_write_attributes_callback( ++ &user_credential_cluster_write_attributes_callback); ++ + uic_mqtt_dotdot_set_protocol_controller_network_management_write_attributes_callback( + &protocol_controller_network_management_cluster_write_attributes_callback); + +diff --git a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c +index d43942b157..81266094a1 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c ++++ b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c +@@ -1260,6 +1260,96 @@ static uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callbac + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t get_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(){ + return test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback; + } ++static uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t test_uic_mqtt_dotdot_user_credential_force_read_attributes_callback = NULL; ++static uic_mqtt_dotdot_user_credential_write_attributes_callback_t test_uic_mqtt_dotdot_user_credential_write_attributes_callback = NULL; ++ ++uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t get_uic_mqtt_dotdot_user_credential_force_read_attributes_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_force_read_attributes_callback; ++} ++uic_mqtt_dotdot_user_credential_write_attributes_callback_t get_uic_mqtt_dotdot_user_credential_write_attributes_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_write_attributes_callback; ++} ++ ++static uic_mqtt_dotdot_user_credential_add_user_callback_t test_uic_mqtt_dotdot_user_credential_add_user_callback = NULL; ++uic_mqtt_dotdot_user_credential_add_user_callback_t get_uic_mqtt_dotdot_user_credential_add_user_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_add_user_callback; ++} ++static uic_mqtt_dotdot_user_credential_modify_user_callback_t test_uic_mqtt_dotdot_user_credential_modify_user_callback = NULL; ++uic_mqtt_dotdot_user_credential_modify_user_callback_t get_uic_mqtt_dotdot_user_credential_modify_user_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_modify_user_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_user_callback_t test_uic_mqtt_dotdot_user_credential_delete_user_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_user_callback_t get_uic_mqtt_dotdot_user_credential_delete_user_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_user_callback; ++} ++static uic_mqtt_dotdot_user_credential_add_credential_callback_t test_uic_mqtt_dotdot_user_credential_add_credential_callback = NULL; ++uic_mqtt_dotdot_user_credential_add_credential_callback_t get_uic_mqtt_dotdot_user_credential_add_credential_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_add_credential_callback; ++} ++static uic_mqtt_dotdot_user_credential_modify_credential_callback_t test_uic_mqtt_dotdot_user_credential_modify_credential_callback = NULL; ++uic_mqtt_dotdot_user_credential_modify_credential_callback_t get_uic_mqtt_dotdot_user_credential_modify_credential_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_modify_credential_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_credential_callback_t test_uic_mqtt_dotdot_user_credential_delete_credential_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_credential_callback_t get_uic_mqtt_dotdot_user_credential_delete_credential_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_credential_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_all_users_callback_t test_uic_mqtt_dotdot_user_credential_delete_all_users_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_all_users_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_users_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_all_users_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback; ++} ++static uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback = NULL; ++uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback; ++} ++static uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback = NULL; ++uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback; ++} ++static uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback = NULL; ++uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback; ++} ++static uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback = NULL; ++uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback; ++} ++static uic_mqtt_dotdot_user_credential_credential_association_callback_t test_uic_mqtt_dotdot_user_credential_credential_association_callback = NULL; ++uic_mqtt_dotdot_user_credential_credential_association_callback_t get_uic_mqtt_dotdot_user_credential_credential_association_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_credential_association_callback; ++} ++static uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback = NULL; ++uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback; ++} ++static uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback = NULL; ++uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback; ++} ++static uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback = NULL; ++uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback; ++} ++static uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback = NULL; ++uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t get_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback; ++} ++static uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback = NULL; ++uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t get_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback(){ ++ return test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback; ++} + static uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t test_uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback = NULL; + static uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t test_uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback = NULL; + +@@ -2856,6 +2946,116 @@ void uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_ + { + test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback = callback; + } ++void set_uic_mqtt_dotdot_user_credential_force_read_attributes_callback_stub( ++ const uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_force_read_attributes_callback = callback; ++} ++void set_uic_mqtt_dotdot_user_credential_write_attributes_callback_stub( ++ const uic_mqtt_dotdot_user_credential_write_attributes_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_write_attributes_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_add_user_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_add_user_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_add_user_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_modify_user_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_modify_user_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_user_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_user_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_add_credential_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_add_credential_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_modify_credential_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_modify_credential_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_modify_credential_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_credential_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_all_users_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_credential_association_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_credential_association_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback = callback; ++} ++void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_stub( ++ const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t callback, int cmock_num_calls) ++{ ++ test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback = callback; ++} + void set_uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_stub( + const uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t callback, int cmock_num_calls) + { +@@ -3818,6 +4018,72 @@ void setUp() + test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback = NULL; + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_set_Stub( + &uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_force_read_attributes_callback = NULL; ++ uic_mqtt_dotdot_set_user_credential_force_read_attributes_callback_Stub( ++ &set_uic_mqtt_dotdot_user_credential_force_read_attributes_callback_stub); ++ test_uic_mqtt_dotdot_user_credential_write_attributes_callback = NULL; ++ uic_mqtt_dotdot_set_user_credential_write_attributes_callback_Stub( ++ &set_uic_mqtt_dotdot_user_credential_write_attributes_callback_stub); ++ test_uic_mqtt_dotdot_user_credential_add_user_callback = NULL; ++ uic_mqtt_dotdot_user_credential_add_user_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_add_user_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_modify_user_callback = NULL; ++ uic_mqtt_dotdot_user_credential_modify_user_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_modify_user_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_user_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_user_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_user_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_add_credential_callback = NULL; ++ uic_mqtt_dotdot_user_credential_add_credential_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_add_credential_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_modify_credential_callback = NULL; ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_modify_credential_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_credential_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_all_users_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback = NULL; ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback = NULL; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback = NULL; ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback = NULL; ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_credential_association_callback = NULL; ++ uic_mqtt_dotdot_user_credential_credential_association_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback = NULL; ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback = NULL; ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback = NULL; ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback = NULL; ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_stub); ++ test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback = NULL; ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_Stub( ++ &uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_stub); + test_uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback = NULL; + uic_mqtt_dotdot_set_protocol_controller_network_management_force_read_attributes_callback_Stub( + &set_uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_stub); +@@ -4604,6 +4870,14 @@ void test_automatic_deduction_of_supported_commands() + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_name_and_location_name(expected_unid,expected_endpoint_id) ); + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_name_and_location_location(expected_unid,expected_endpoint_id) ); + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_configuration_parameters_configuration_parameters(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_supported_user_unique_identifiers(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_supported_credential_rules(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_supported_credential_types(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_supported_user_types(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_support_credential_checksum(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_support_admin_pin_code(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_support_admin_pin_code_deactivation(expected_unid,expected_endpoint_id) ); ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_user_credential_admin_pin_code(expected_unid,expected_endpoint_id) ); + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_protocol_controller_network_management_network_management_state(expected_unid,expected_endpoint_id) ); + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_descriptor_device_type_list(expected_unid,expected_endpoint_id) ); + TEST_ASSERT_EQUAL(SL_STATUS_OK, dotdot_create_unify_fan_control_z_wave_fan_mode(expected_unid,expected_endpoint_id) ); +@@ -4652,7 +4926,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_callback) { + // Dummy command parameters +- uint16_t identify_time_value; ++ int16_t identify_time_value; + memset(&identify_time_value, 0x00, sizeof(identify_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_identify_identify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4663,7 +4937,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_query_response_callback) { + // Dummy command parameters +- uint16_t timeout_value; ++ int16_t timeout_value; + memset(&timeout_value, 0x00, sizeof(timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_identify_identify_query_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4696,7 +4970,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -4713,7 +4987,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_add_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4726,7 +5000,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_view_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_view_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4739,7 +5013,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -4765,7 +5039,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + // Dummy command parameters +- uint8_t capacity_value; ++ int8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_get_group_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4778,7 +5052,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_remove_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_remove_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4791,7 +5065,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_remove_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4811,7 +5085,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -4826,15 +5100,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_add_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- uint8_t transition_time100ms_value; ++ int8_t transition_time100ms_value; + memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4857,9 +5131,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4874,9 +5148,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_view_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4891,13 +5165,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4918,9 +5192,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4935,9 +5209,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4952,7 +5226,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4965,7 +5239,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4978,9 +5252,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_store_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_store_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4995,9 +5269,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_store_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5012,11 +5286,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_recall_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_recall_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5031,7 +5305,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_get_scene_membership_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5044,9 +5318,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t capacity_value; ++ int8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_get_scene_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5063,13 +5337,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5090,9 +5364,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5107,9 +5381,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5124,13 +5398,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5153,13 +5427,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t mode_value; + memset(&mode_value, 0x00, sizeof(mode_value)); +- uint16_t group_identifier_from_value; ++ uint8_t * group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; ++ int8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint16_t group_identifier_to_value; ++ uint8_t * group_identifier_to_value; + memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- uint8_t scene_identifier_to_value; ++ int8_t scene_identifier_to_value; + memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_copy_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5180,9 +5454,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_identifier_from_value; ++ uint8_t * group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; ++ int8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_copy_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5220,7 +5494,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + OffWithEffectEffectIdentifier effect_identifier_value; + memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- uint8_t effect_variant_value; ++ int8_t effect_variant_value; + memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_on_off_off_with_effect_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5242,9 +5516,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t on_off_control_value; + memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- uint16_t on_time_value; ++ int16_t on_time_value; + memset(&on_time_value, 0x00, sizeof(on_time_value)); +- uint16_t off_wait_time_value; ++ int16_t off_wait_time_value; + memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_on_off_on_with_timed_off_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5259,9 +5533,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_callback) { + // Dummy command parameters +- uint8_t level_value; ++ int8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5284,7 +5558,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5307,9 +5581,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5347,9 +5621,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { + // Dummy command parameters +- uint8_t level_value; ++ int8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5372,7 +5646,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5395,9 +5669,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5435,7 +5709,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { + // Dummy command parameters +- uint16_t frequency_value; ++ int16_t frequency_value; + memset(&frequency_value, 0x00, sizeof(frequency_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5448,7 +5722,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_reset_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5463,7 +5737,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5487,9 +5761,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- uint32_t time_stamp_value; ++ int32_t time_stamp_value; + memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_get_alarm_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5529,7 +5803,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + bool start_fast_polling_value; + memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- uint16_t fast_poll_timeout_value; ++ int16_t fast_poll_timeout_value; + memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_check_in_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5549,7 +5823,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { + // Dummy command parameters +- uint32_t new_long_poll_interval_value; ++ int32_t new_long_poll_interval_value; + memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5560,7 +5834,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { + // Dummy command parameters +- uint16_t new_short_poll_interval_value; ++ int16_t new_short_poll_interval_value; + memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5571,7 +5845,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_lock_door_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_lock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5593,7 +5867,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_door_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unlock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5615,7 +5889,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_toggle_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_toggle_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5637,9 +5911,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { + // Dummy command parameters +- uint16_t timeout_in_seconds_value; ++ int16_t timeout_in_seconds_value; + memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5663,7 +5937,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_callback) { + // Dummy command parameters +- uint16_t log_index_value; ++ int16_t log_index_value; + memset(&log_index_value, 0x00, sizeof(log_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_log_record_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5674,19 +5948,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { + // Dummy command parameters +- uint16_t log_entryid_value; ++ int16_t log_entryid_value; + memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- uint32_t timestamp_value; ++ int32_t timestamp_value; + memset(×tamp_value, 0x00, sizeof(timestamp_value)); + GetLogRecordResponseEventType event_type_value; + memset(&event_type_value, 0x00, sizeof(event_type_value)); + DrlkOperEventSource source_operation_event_value; + memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- uint8_t event_id_or_alarm_code_value; ++ int8_t event_id_or_alarm_code_value; + memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5709,13 +5983,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5743,7 +6017,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5754,13 +6028,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* code_value; ++ uint8_t code_value; + memset(&code_value, 0x00, sizeof(code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5777,7 +6051,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5817,7 +6091,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_status_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -5843,7 +6117,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_status_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5854,7 +6128,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -5869,19 +6143,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; ++ int8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; ++ int8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; ++ int8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; ++ int8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5915,9 +6189,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5930,21 +6204,21 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ int8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; ++ int8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; ++ int8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; ++ int8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; ++ int8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5969,9 +6243,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5995,13 +6269,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6029,9 +6303,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6044,15 +6318,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ int8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6071,9 +6345,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6097,11 +6371,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -6131,7 +6405,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6142,13 +6416,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ int8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -6169,7 +6443,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6191,7 +6465,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_type_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -6217,7 +6491,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6228,7 +6502,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -6243,13 +6517,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; ++ uint8_t rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6277,7 +6551,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6288,13 +6562,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; ++ uint8_t rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6311,7 +6585,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6353,11 +6627,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + DataOperationTypeEnum operation_type_value; + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- uint32_t user_uniqueid_value; ++ int32_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6386,7 +6660,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_callback) { + // Dummy command parameters +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6404,7 +6678,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_user_callback) { + // Dummy command parameters +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6419,11 +6693,11 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); + OperatingEventNotificationOperationEventCode operation_event_code_value; + memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); +- uint32_t local_time_value; ++ int32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -6450,15 +6724,15 @@ void test_automatic_deduction_of_supported_commands() + memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); + ProgrammingEventNotificationProgramEventCode program_event_code_value; + memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +- uint32_t local_time_value; ++ int32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -6489,9 +6763,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); + CredentialStruct credential_value; + memset(&credential_value, 0x00, sizeof(credential_value)); +- const char* credential_data_value; ++ uint8_t credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6552,7 +6826,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unbolt_door_callback) { + // Dummy command parameters +- const char* pin_code_value; ++ uint8_t pin_code_value; + memset(&pin_code_value, 0x00, sizeof(pin_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unbolt_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6584,7 +6858,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + // Dummy command parameters +- uint16_t lift_value_value; ++ int16_t lift_value_value; + memset(&lift_value_value, 0x00, sizeof(lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6595,7 +6869,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + // Dummy command parameters +- uint8_t percentage_lift_value_value; ++ int8_t percentage_lift_value_value; + memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6606,7 +6880,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + // Dummy command parameters +- uint16_t tilt_value_value; ++ int16_t tilt_value_value; + memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6617,7 +6891,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + // Dummy command parameters +- uint8_t percentage_tilt_value_value; ++ int8_t percentage_tilt_value_value; + memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6628,7 +6902,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + // Dummy command parameters +- uint8_t percent_open_value; ++ int8_t percent_open_value; + memset(&percent_open_value, 0x00, sizeof(percent_open_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6703,17 +6977,17 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { + // Dummy command parameters +- uint16_t time_of_day_value; ++ int16_t time_of_day_value; + memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); + uint8_t relay_status_value; + memset(&relay_status_value, 0x00, sizeof(relay_status_value)); + int16_t local_temperature_value; + memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- uint8_t humidity_percentage_value; ++ int8_t humidity_percentage_value; + memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); + int16_t set_point_value; + memset(&set_point_value, 0x00, sizeof(set_point_value)); +- uint16_t unread_entries_value; ++ int16_t unread_entries_value; + memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6763,11 +7037,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_callback) { + // Dummy command parameters +- uint8_t hue_value; ++ int8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6792,7 +7066,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6815,9 +7089,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; ++ int8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6840,9 +7114,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_saturation_callback) { + // Dummy command parameters +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6865,7 +7139,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6888,9 +7162,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; ++ int8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6913,11 +7187,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- uint8_t hue_value; ++ int8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6940,11 +7214,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_callback) { + // Dummy command parameters +- uint16_t colorx_value; ++ int16_t colorx_value; + memset(&colorx_value, 0x00, sizeof(colorx_value)); +- uint16_t colory_value; ++ int16_t colory_value; + memset(&colory_value, 0x00, sizeof(colory_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -6994,7 +7268,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&stepx_value, 0x00, sizeof(stepx_value)); + int16_t stepy_value; + memset(&stepy_value, 0x00, sizeof(stepy_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7017,9 +7291,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { + // Dummy command parameters +- uint16_t color_temperature_mireds_value; ++ int16_t color_temperature_mireds_value; + memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7040,11 +7314,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { + // Dummy command parameters +- uint16_t enhanced_hue_value; ++ int16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7069,7 +7343,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; ++ int16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7092,9 +7366,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; ++ int16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7117,11 +7391,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- uint16_t enhanced_hue_value; ++ int16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7150,9 +7424,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&action_value, 0x00, sizeof(action_value)); + CCColorLoopDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t time_value; ++ int16_t time_value; + memset(&time_value, 0x00, sizeof(time_value)); +- uint16_t start_hue_value; ++ int16_t start_hue_value; + memset(&start_hue_value, 0x00, sizeof(start_hue_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7196,11 +7470,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; ++ int16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); +- uint16_t color_temperature_minimum_mireds_value; ++ uint8_t * color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; ++ uint8_t * color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7227,13 +7501,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; ++ int16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint16_t color_temperature_minimum_mireds_value; ++ uint8_t * color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; ++ uint8_t * color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7262,7 +7536,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; + memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- uint8_t zoneid_value; ++ int8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7279,9 +7553,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&zone_status_value, 0x00, sizeof(zone_status_value)); + uint8_t extended_status_value; + memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- uint8_t zoneid_value; ++ int8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- uint16_t delay_value; ++ int16_t delay_value; + memset(&delay_value, 0x00, sizeof(delay_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7307,7 +7581,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + IasZoneType zone_type_value; + memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- uint16_t manufacturer_code_value; ++ int16_t manufacturer_code_value; + memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7320,9 +7594,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { + // Dummy command parameters +- uint8_t test_mode_duration_value; ++ int8_t test_mode_duration_value; + memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- uint8_t current_zone_sensitivity_level_value; ++ int8_t current_zone_sensitivity_level_value; + memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7337,9 +7611,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t siren_configuration_value; + memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- uint16_t warning_duration_value; ++ int16_t warning_duration_value; + memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- uint8_t strobe_duty_cycle_value; ++ int8_t strobe_duty_cycle_value; + memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); + IaswdLevel strobe_level_value; + memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +@@ -7369,11 +7643,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { + // Dummy command parameters +- uint8_t profile_count_value; ++ int8_t profile_count_value; + memset(&profile_count_value, 0x00, sizeof(profile_count_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t max_number_of_intervals_value; ++ int8_t max_number_of_intervals_value; + memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7397,15 +7671,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { + // Dummy command parameters +- uint32_t start_time_value; ++ uint8_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); + GetMeasurementProfileResponseStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t number_of_intervals_delivered_value; ++ int8_t number_of_intervals_delivered_value; + memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint16_t attribute_id_value; ++ uint8_t attribute_id_value; + memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7426,11 +7700,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { + // Dummy command parameters +- uint16_t attributeid_value; ++ uint8_t attributeid_value; + memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint32_t start_time_value; ++ uint8_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); +- uint8_t number_of_intervals_value; ++ int8_t number_of_intervals_value; + memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7451,13 +7725,13 @@ void test_automatic_deduction_of_supported_commands() + memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); + bool transmission_successful_value; + memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- uint16_t transmission_time_ms_value; ++ int16_t transmission_time_ms_value; + memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); + int8_t tx_powerd_bm_value; + memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- uint8_t tx_channel_value; ++ int8_t tx_channel_value; + memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- uint8_t routing_attempts_value; ++ int8_t routing_attempts_value; + memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); + bool route_changed_value; + memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +@@ -7467,7 +7741,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); + int8_t ackrssi_value; + memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- uint8_t ack_channel_value; ++ int8_t ack_channel_value; + memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); + const char* last_route_failed_link_functionalunid_value; + memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +@@ -7570,7 +7844,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; ++ int8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_binding_bind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7589,7 +7863,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; ++ int8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_binding_unbind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7649,7 +7923,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { + // Dummy command parameters +- uint16_t parameter_id_value; ++ int16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7667,7 +7941,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { + // Dummy command parameters +- uint16_t parameter_id_value; ++ int16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + int64_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -7682,9 +7956,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { + // Dummy command parameters +- uint16_t first_parameter_id_value; ++ int16_t first_parameter_id_value; + memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- uint16_t last_parameter_id_value; ++ int16_t last_parameter_id_value; + memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7695,6 +7969,330 @@ void test_automatic_deduction_of_supported_commands() + + )); + } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_add_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_add_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_modify_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_modify_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_add_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_add_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_modify_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_modify_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_users_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_users_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_association_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t source_user_uniqueid_value; ++ memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); ++ int16_t source_credential_slot_value; ++ memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); ++ int16_t destination_user_uniqueid_value; ++ memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); ++ int16_t destination_credential_slot_value; ++ memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_association_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value, ++ ++ source_user_uniqueid_value, ++ ++ source_credential_slot_value, ++ ++ destination_user_uniqueid_value, ++ ++ destination_credential_slot_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback) { ++ // Dummy command parameters ++ const char* pin_code_value; ++ memset(&pin_code_value, 0x00, sizeof(pin_code_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_code_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } + if (NULL != test_uic_mqtt_dotdot_protocol_controller_network_management_write_callback) { + // Dummy command parameters + // Invoke with support check +@@ -7735,9 +8333,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + SetpointType type_value; + memset(&type_value, 0x00, sizeof(type_value)); +- uint8_t precision_value; ++ int8_t precision_value; + memset(&precision_value, 0x00, sizeof(precision_value)); +- uint8_t scale_value; ++ int8_t scale_value; + memset(&scale_value, 0x00, sizeof(scale_value)); + int32_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -7767,7 +8365,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_callback) { + // Dummy command parameters +- uint16_t identify_time_value; ++ int16_t identify_time_value; + memset(&identify_time_value, 0x00, sizeof(identify_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_identify_identify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7778,7 +8376,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_query_response_callback) { + // Dummy command parameters +- uint16_t timeout_value; ++ int16_t timeout_value; + memset(&timeout_value, 0x00, sizeof(timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_identify_identify_query_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7811,7 +8409,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -7828,7 +8426,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_add_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7841,7 +8439,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_view_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_view_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7854,7 +8452,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -7880,7 +8478,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + // Dummy command parameters +- uint8_t capacity_value; ++ int8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_get_group_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7893,7 +8491,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_remove_group_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_remove_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7906,7 +8504,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_remove_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7926,7 +8524,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { + // Dummy command parameters +- uint16_t group_id_value; ++ int16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -7941,15 +8539,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_add_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- uint8_t transition_time100ms_value; ++ int8_t transition_time100ms_value; + memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7972,9 +8570,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7989,9 +8587,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_view_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8006,13 +8604,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8033,9 +8631,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8050,9 +8648,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8067,7 +8665,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8080,7 +8678,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8093,9 +8691,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_store_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_store_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8110,9 +8708,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_store_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8127,11 +8725,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_recall_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_recall_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8146,7 +8744,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_get_scene_membership_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8159,9 +8757,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t capacity_value; ++ int8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_get_scene_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8178,13 +8776,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8205,9 +8803,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8222,9 +8820,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + // Dummy command parameters +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8239,13 +8837,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t groupid_value; ++ uint8_t * groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- uint8_t sceneid_value; ++ int8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- const char* scene_name_value; ++ uint8_t * scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8268,13 +8866,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t mode_value; + memset(&mode_value, 0x00, sizeof(mode_value)); +- uint16_t group_identifier_from_value; ++ uint8_t * group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; ++ int8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint16_t group_identifier_to_value; ++ uint8_t * group_identifier_to_value; + memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- uint8_t scene_identifier_to_value; ++ int8_t scene_identifier_to_value; + memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_copy_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8295,9 +8893,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint16_t group_identifier_from_value; ++ uint8_t * group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- uint8_t scene_identifier_from_value; ++ int8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_copy_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8335,7 +8933,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + OffWithEffectEffectIdentifier effect_identifier_value; + memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- uint8_t effect_variant_value; ++ int8_t effect_variant_value; + memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_on_off_off_with_effect_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8357,9 +8955,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t on_off_control_value; + memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- uint16_t on_time_value; ++ int16_t on_time_value; + memset(&on_time_value, 0x00, sizeof(on_time_value)); +- uint16_t off_wait_time_value; ++ int16_t off_wait_time_value; + memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_on_off_on_with_timed_off_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8374,9 +8972,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_callback) { + // Dummy command parameters +- uint8_t level_value; ++ int8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8399,7 +8997,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8422,9 +9020,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8462,9 +9060,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { + // Dummy command parameters +- uint8_t level_value; ++ int8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8487,7 +9085,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8510,9 +9108,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8550,7 +9148,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { + // Dummy command parameters +- uint16_t frequency_value; ++ int16_t frequency_value; + memset(&frequency_value, 0x00, sizeof(frequency_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8563,7 +9161,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_reset_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8578,7 +9176,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8602,9 +9200,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint16_t cluster_identifier_value; ++ uint8_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- uint32_t time_stamp_value; ++ int32_t time_stamp_value; + memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_get_alarm_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8644,7 +9242,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + bool start_fast_polling_value; + memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- uint16_t fast_poll_timeout_value; ++ int16_t fast_poll_timeout_value; + memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_check_in_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8664,7 +9262,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { + // Dummy command parameters +- uint32_t new_long_poll_interval_value; ++ int32_t new_long_poll_interval_value; + memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8675,7 +9273,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { + // Dummy command parameters +- uint16_t new_short_poll_interval_value; ++ int16_t new_short_poll_interval_value; + memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8686,7 +9284,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_lock_door_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_lock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8708,7 +9306,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_door_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unlock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8730,7 +9328,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_toggle_callback) { + // Dummy command parameters +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_toggle_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8752,9 +9350,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { + // Dummy command parameters +- uint16_t timeout_in_seconds_value; ++ int16_t timeout_in_seconds_value; + memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- const char* pin_or_rfid_code_value; ++ uint8_t pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8778,7 +9376,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_callback) { + // Dummy command parameters +- uint16_t log_index_value; ++ int16_t log_index_value; + memset(&log_index_value, 0x00, sizeof(log_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_log_record_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8789,19 +9387,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { + // Dummy command parameters +- uint16_t log_entryid_value; ++ int16_t log_entryid_value; + memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- uint32_t timestamp_value; ++ int32_t timestamp_value; + memset(×tamp_value, 0x00, sizeof(timestamp_value)); + GetLogRecordResponseEventType event_type_value; + memset(&event_type_value, 0x00, sizeof(event_type_value)); + DrlkOperEventSource source_operation_event_value; + memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- uint8_t event_id_or_alarm_code_value; ++ int8_t event_id_or_alarm_code_value; + memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8824,13 +9422,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8858,7 +9456,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8869,13 +9467,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* code_value; ++ uint8_t code_value; + memset(&code_value, 0x00, sizeof(code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8892,7 +9490,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8932,7 +9530,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_status_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -8958,7 +9556,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_status_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8969,7 +9567,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -8984,19 +9582,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; ++ int8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; ++ int8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; ++ int8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; ++ int8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9030,9 +9628,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9045,21 +9643,21 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ int8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- uint8_t start_hour_value; ++ int8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- uint8_t start_minute_value; ++ int8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- uint8_t end_hour_value; ++ int8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- uint8_t end_minute_value; ++ int8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9084,9 +9682,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9110,13 +9708,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9144,9 +9742,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9159,15 +9757,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ int8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9186,9 +9784,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t scheduleid_value; ++ uint8_t * scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9212,11 +9810,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -9246,7 +9844,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9257,13 +9855,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ int8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint32_t local_start_time_value; ++ int32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- uint32_t local_end_time_value; ++ int32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -9284,7 +9882,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t holiday_scheduleid_value; ++ uint8_t * holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9306,7 +9904,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_type_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -9332,7 +9930,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9343,7 +9941,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -9358,13 +9956,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; ++ uint8_t rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9392,7 +9990,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9403,13 +10001,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- const char* rfid_code_value; ++ uint8_t rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9426,7 +10024,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { + // Dummy command parameters +- uint16_t userid_value; ++ uint8_t * userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9468,11 +10066,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + DataOperationTypeEnum operation_type_value; + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- uint32_t user_uniqueid_value; ++ int32_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -9501,7 +10099,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_callback) { + // Dummy command parameters +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9519,7 +10117,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_user_callback) { + // Dummy command parameters +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9534,11 +10132,11 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); + OperatingEventNotificationOperationEventCode operation_event_code_value; + memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); +- uint32_t local_time_value; ++ int32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -9565,15 +10163,15 @@ void test_automatic_deduction_of_supported_commands() + memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); + ProgrammingEventNotificationProgramEventCode program_event_code_value; + memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- uint16_t userid_value; ++ int16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- const char* pin_value; ++ uint8_t pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +- uint32_t local_time_value; ++ int32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -9604,9 +10202,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); + CredentialStruct credential_value; + memset(&credential_value, 0x00, sizeof(credential_value)); +- const char* credential_data_value; ++ uint8_t credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- uint16_t user_index_value; ++ int16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -9667,7 +10265,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unbolt_door_callback) { + // Dummy command parameters +- const char* pin_code_value; ++ uint8_t pin_code_value; + memset(&pin_code_value, 0x00, sizeof(pin_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unbolt_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9699,7 +10297,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + // Dummy command parameters +- uint16_t lift_value_value; ++ int16_t lift_value_value; + memset(&lift_value_value, 0x00, sizeof(lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9710,7 +10308,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + // Dummy command parameters +- uint8_t percentage_lift_value_value; ++ int8_t percentage_lift_value_value; + memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9721,7 +10319,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + // Dummy command parameters +- uint16_t tilt_value_value; ++ int16_t tilt_value_value; + memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9732,7 +10330,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + // Dummy command parameters +- uint8_t percentage_tilt_value_value; ++ int8_t percentage_tilt_value_value; + memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9743,7 +10341,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + // Dummy command parameters +- uint8_t percent_open_value; ++ int8_t percent_open_value; + memset(&percent_open_value, 0x00, sizeof(percent_open_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9818,17 +10416,17 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { + // Dummy command parameters +- uint16_t time_of_day_value; ++ int16_t time_of_day_value; + memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); + uint8_t relay_status_value; + memset(&relay_status_value, 0x00, sizeof(relay_status_value)); + int16_t local_temperature_value; + memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- uint8_t humidity_percentage_value; ++ int8_t humidity_percentage_value; + memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); + int16_t set_point_value; + memset(&set_point_value, 0x00, sizeof(set_point_value)); +- uint16_t unread_entries_value; ++ int16_t unread_entries_value; + memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9878,11 +10476,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_callback) { + // Dummy command parameters +- uint8_t hue_value; ++ int8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9907,7 +10505,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9930,9 +10528,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; ++ int8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9955,9 +10553,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_saturation_callback) { + // Dummy command parameters +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9980,7 +10578,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint8_t rate_value; ++ int8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10003,9 +10601,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint8_t step_size_value; ++ int8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint8_t transition_time_value; ++ int8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10028,11 +10626,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- uint8_t hue_value; ++ int8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10055,11 +10653,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_callback) { + // Dummy command parameters +- uint16_t colorx_value; ++ int16_t colorx_value; + memset(&colorx_value, 0x00, sizeof(colorx_value)); +- uint16_t colory_value; ++ int16_t colory_value; + memset(&colory_value, 0x00, sizeof(colory_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10109,7 +10707,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&stepx_value, 0x00, sizeof(stepx_value)); + int16_t stepy_value; + memset(&stepy_value, 0x00, sizeof(stepy_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10132,9 +10730,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { + // Dummy command parameters +- uint16_t color_temperature_mireds_value; ++ int16_t color_temperature_mireds_value; + memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10155,11 +10753,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { + // Dummy command parameters +- uint16_t enhanced_hue_value; ++ int16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10184,7 +10782,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; ++ int16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10207,9 +10805,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; ++ int16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10232,11 +10830,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- uint16_t enhanced_hue_value; ++ int16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- uint8_t saturation_value; ++ int8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10265,9 +10863,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&action_value, 0x00, sizeof(action_value)); + CCColorLoopDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- uint16_t time_value; ++ int16_t time_value; + memset(&time_value, 0x00, sizeof(time_value)); +- uint16_t start_hue_value; ++ int16_t start_hue_value; + memset(&start_hue_value, 0x00, sizeof(start_hue_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10311,11 +10909,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- uint16_t rate_value; ++ int16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); +- uint16_t color_temperature_minimum_mireds_value; ++ uint8_t * color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; ++ uint8_t * color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10342,13 +10940,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- uint16_t step_size_value; ++ int16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- uint16_t transition_time_value; ++ int16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint16_t color_temperature_minimum_mireds_value; ++ uint8_t * color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint16_t color_temperature_maximum_mireds_value; ++ uint8_t * color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10377,7 +10975,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; + memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- uint8_t zoneid_value; ++ int8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10394,9 +10992,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&zone_status_value, 0x00, sizeof(zone_status_value)); + uint8_t extended_status_value; + memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- uint8_t zoneid_value; ++ int8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- uint16_t delay_value; ++ int16_t delay_value; + memset(&delay_value, 0x00, sizeof(delay_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10422,7 +11020,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + IasZoneType zone_type_value; + memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- uint16_t manufacturer_code_value; ++ int16_t manufacturer_code_value; + memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10435,9 +11033,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { + // Dummy command parameters +- uint8_t test_mode_duration_value; ++ int8_t test_mode_duration_value; + memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- uint8_t current_zone_sensitivity_level_value; ++ int8_t current_zone_sensitivity_level_value; + memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10452,9 +11050,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t siren_configuration_value; + memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- uint16_t warning_duration_value; ++ int16_t warning_duration_value; + memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- uint8_t strobe_duty_cycle_value; ++ int8_t strobe_duty_cycle_value; + memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); + IaswdLevel strobe_level_value; + memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +@@ -10484,11 +11082,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { + // Dummy command parameters +- uint8_t profile_count_value; ++ int8_t profile_count_value; + memset(&profile_count_value, 0x00, sizeof(profile_count_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t max_number_of_intervals_value; ++ int8_t max_number_of_intervals_value; + memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10512,15 +11110,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { + // Dummy command parameters +- uint32_t start_time_value; ++ uint8_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); + GetMeasurementProfileResponseStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- uint8_t number_of_intervals_delivered_value; ++ int8_t number_of_intervals_delivered_value; + memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint16_t attribute_id_value; ++ uint8_t attribute_id_value; + memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10541,11 +11139,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { + // Dummy command parameters +- uint16_t attributeid_value; ++ uint8_t attributeid_value; + memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint32_t start_time_value; ++ uint8_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); +- uint8_t number_of_intervals_value; ++ int8_t number_of_intervals_value; + memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10566,13 +11164,13 @@ void test_automatic_deduction_of_supported_commands() + memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); + bool transmission_successful_value; + memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- uint16_t transmission_time_ms_value; ++ int16_t transmission_time_ms_value; + memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); + int8_t tx_powerd_bm_value; + memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- uint8_t tx_channel_value; ++ int8_t tx_channel_value; + memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- uint8_t routing_attempts_value; ++ int8_t routing_attempts_value; + memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); + bool route_changed_value; + memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +@@ -10582,7 +11180,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); + int8_t ackrssi_value; + memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- uint8_t ack_channel_value; ++ int8_t ack_channel_value; + memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); + const char* last_route_failed_link_functionalunid_value; + memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +@@ -10685,7 +11283,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; ++ int8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_binding_bind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10704,7 +11302,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- uint8_t destination_ep_value; ++ int8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_binding_unbind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10764,7 +11362,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { + // Dummy command parameters +- uint16_t parameter_id_value; ++ int16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10782,7 +11380,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { + // Dummy command parameters +- uint16_t parameter_id_value; ++ int16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + int64_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -10797,9 +11395,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { + // Dummy command parameters +- uint16_t first_parameter_id_value; ++ int16_t first_parameter_id_value; + memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- uint16_t last_parameter_id_value; ++ int16_t last_parameter_id_value; + memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10810,6 +11408,330 @@ void test_automatic_deduction_of_supported_commands() + + )); + } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_add_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_add_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_modify_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ UserTypeEnum user_type_value; ++ memset(&user_type_value, 0x00, sizeof(user_type_value)); ++ bool user_active_state_value; ++ memset(&user_active_state_value, 0x00, sizeof(user_active_state_value)); ++ CredRule credential_rule_value; ++ memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); ++ const char* user_name_value; ++ memset(&user_name_value, 0x00, sizeof(user_name_value)); ++ int16_t expiring_timeout_minutes_value; ++ memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); ++ UserNameEncodingType user_name_encoding_value; ++ memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_modify_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ user_type_value, ++ ++ user_active_state_value, ++ ++ credential_rule_value, ++ ++ user_name_value, ++ ++ expiring_timeout_minutes_value, ++ ++ user_name_encoding_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_add_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_add_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_modify_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ const char* credential_data_value; ++ memset(&credential_data_value, 0x00, sizeof(credential_data_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_modify_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_data_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_credential_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_users_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_users_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t credential_slot_value; ++ memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); ++ int8_t credential_learn_timeout_value; ++ memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value, ++ ++ credential_type_value, ++ ++ credential_slot_value, ++ ++ credential_learn_timeout_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_credential_association_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ int16_t source_user_uniqueid_value; ++ memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); ++ int16_t source_credential_slot_value; ++ memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); ++ int16_t destination_user_uniqueid_value; ++ memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); ++ int16_t destination_credential_slot_value; ++ memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_association_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value, ++ ++ source_user_uniqueid_value, ++ ++ source_credential_slot_value, ++ ++ destination_user_uniqueid_value, ++ ++ destination_credential_slot_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { ++ // Dummy command parameters ++ int16_t user_uniqueid_value; ++ memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ user_uniqueid_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback) { ++ // Dummy command parameters ++ CredType credential_type_value; ++ memset(&credential_type_value, 0x00, sizeof(credential_type_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ credential_type_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback) { ++ // Dummy command parameters ++ const char* pin_code_value; ++ memset(&pin_code_value, 0x00, sizeof(pin_code_value)); ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ , ++ pin_code_value ++ ++ )); ++ } ++ if (NULL != test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback) { ++ // Dummy command parameters ++ // Invoke with support check ++ TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK ++ ++ )); ++ } + if (NULL != test_uic_mqtt_dotdot_protocol_controller_network_management_write_callback) { + // Dummy command parameters + // Invoke with support check +@@ -10850,9 +11772,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + SetpointType type_value; + memset(&type_value, 0x00, sizeof(type_value)); +- uint8_t precision_value; ++ int8_t precision_value; + memset(&precision_value, 0x00, sizeof(precision_value)); +- uint8_t scale_value; ++ int8_t scale_value; + memset(&scale_value, 0x00, sizeof(scale_value)); + int32_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +diff --git a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.h b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.h +index 73c36434ca..d5c2ed0913 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.h ++++ b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.h +@@ -769,6 +769,70 @@ + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_t get_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(); + + ++ uic_mqtt_dotdot_user_credential_force_read_attributes_callback_t get_uic_mqtt_dotdot_user_credential_force_read_attributes_callback(); ++ uic_mqtt_dotdot_user_credential_write_attributes_callback_t get_uic_mqtt_dotdot_user_credential_write_attributes_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_add_user_callback_t get_uic_mqtt_dotdot_user_credential_add_user_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_modify_user_callback_t get_uic_mqtt_dotdot_user_credential_modify_user_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_user_callback_t get_uic_mqtt_dotdot_user_credential_delete_user_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_add_credential_callback_t get_uic_mqtt_dotdot_user_credential_add_credential_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_modify_credential_callback_t get_uic_mqtt_dotdot_user_credential_modify_credential_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_credential_callback_t get_uic_mqtt_dotdot_user_credential_delete_credential_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_all_users_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_users_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t get_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t get_uic_mqtt_dotdot_user_credential_credential_learn_stop_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_credential_association_callback_t get_uic_mqtt_dotdot_user_credential_credential_association_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_credential_checksum_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t get_uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t get_uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback(); ++ ++ ++ uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t get_uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback(); ++ ++ + uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback_t get_uic_mqtt_dotdot_protocol_controller_network_management_force_read_attributes_callback(); + uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback_t get_uic_mqtt_dotdot_protocol_controller_network_management_write_attributes_callback(); + +-- +2.39.5 + diff --git a/patches/UnifySDK/0009-UIC-3222-Unify_UserCredential-cluster-integration-in.patch b/patches/UnifySDK/0009-UIC-3222-Unify_UserCredential-cluster-integration-in.patch new file mode 100644 index 000000000..e667e0353 --- /dev/null +++ b/patches/UnifySDK/0009-UIC-3222-Unify_UserCredential-cluster-integration-in.patch @@ -0,0 +1,997 @@ +From 7ecce320cb8f6727a508f0da13b43752181e624c Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Tue, 17 Sep 2024 11:38:53 +0200 +Subject: [PATCH] UIC-3222: Unify_UserCredential cluster integration in Dev-GUI + +UIC-3222: Credential Commands improved in DevGUI +UIC-3222: Fix DevUi if no Users are on the device + +Allow to send commands even if no user is currently defined +UIC-3222: Fix Credential deletion commands +UIC-3222: Fix Credential Defined slots in UI +UIC-3222: Learn Support in DevUI +UIC-3222: AdminPINCode in DevUI +--- + applications/dev_ui/dev_gui/src/App.tsx | 2 + + .../base-clusters/cluster-view-overrides.tsx | 21 +- + .../cred-dlg/cred-dlg-types.tsx | 10 + + .../user-credential/cred-dlg/cred-dlg.tsx | 110 ++++++ + .../user-credential-attrs.tsx | 244 +++++++++++++ + .../user-credential/user-credential-types.tsx | 10 + + .../pages/user-credential/user-credential.tsx | 326 ++++++++++++++++++ + .../user-dlg/user-dlg-types.tsx | 10 + + .../user-credential/user-dlg/user-dlg.tsx | 130 +++++++ + .../dev_ui/dev_gui/zap/addon-helper.js | 3 +- + 10 files changed, 864 insertions(+), 2 deletions(-) + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg-types.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-attrs/user-credential-attrs.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-types.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg-types.tsx + create mode 100644 applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg.tsx + +diff --git a/applications/dev_ui/dev_gui/src/App.tsx b/applications/dev_ui/dev_gui/src/App.tsx +index 880130d887..92e17f0c9a 100644 +--- a/applications/dev_ui/dev_gui/src/App.tsx ++++ b/applications/dev_ui/dev_gui/src/App.tsx +@@ -32,6 +32,7 @@ import Scene from './pages/scenes/scene/scene'; + import EpScenes from './pages/scenes/ep-scenes/ep-scenes'; + import { CommissionableDevices } from './pages/commissionable-devices/commissionable-devices'; + import { Button, Modal, Spinner } from 'react-bootstrap'; ++import UserCredential from './pages/user-credential/user-credential'; + + class App extends Component<{}, AppState> { + constructor(props: {}) { +@@ -276,6 +277,7 @@ class App extends Component<{}, AppState> { + } /> + } /> + } /> ++ } /> + + {Object.keys(ClusterTypes).map((type, index) => + i.name === type)?.path} render={() => +diff --git a/applications/dev_ui/dev_gui/src/pages/base-clusters/cluster-view-overrides.tsx b/applications/dev_ui/dev_gui/src/pages/base-clusters/cluster-view-overrides.tsx +index 662fc62c18..c696247586 100644 +--- a/applications/dev_ui/dev_gui/src/pages/base-clusters/cluster-view-overrides.tsx ++++ b/applications/dev_ui/dev_gui/src/pages/base-clusters/cluster-view-overrides.tsx +@@ -10,7 +10,7 @@ import { ClusterTypes } from '../../cluster-types/cluster-types'; + import { ClusterViewOverride } from './base-cluster-types'; + import { Link } from 'react-router-dom'; + import { Tooltip } from '@mui/material'; +-import { Button } from 'react-bootstrap'; ++import { Button, Badge } from 'react-bootstrap'; + + //Here you can find icons that can be used to customize you page: https://react-icons.github.io/react-icons/ + //Don`t forgot to check licence if you use something that is not in Licence.txt +@@ -749,4 +749,23 @@ export let ClusterViewOverrides = { + } as NavbarItem, + IsExpandable: true + } as ClusterViewOverride, ++ ++ UserCredential: { ++ NodesTooltip: (endpoint: string) => ++ ++ ++ ++ ++ ++ ++ , ++ NavbarItem: { ++ name: "User Credential", ++ title: 'User Credential', ++ path: '/usercredential', ++ icon: , ++ cName: 'nav-text', ++ subMenu: SideMenu.Actuators ++ } as NavbarItem ++ } as ClusterViewOverride, + } +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg-types.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg-types.tsx +new file mode 100644 +index 0000000000..76e9c0e53e +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg-types.tsx +@@ -0,0 +1,10 @@ ++export type UserDlgState = { ++ Command: any, ++ Unid: any, ++ ShowModal: boolean, ++ UserCredential: any ++} ++ ++export type UserDlgProps = { ++ SocketServer: WebSocket ++} +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg.tsx +new file mode 100644 +index 0000000000..638dd1b3f3 +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/cred-dlg/cred-dlg.tsx +@@ -0,0 +1,110 @@ ++import * as React from 'react'; ++import { Button, Modal } from 'react-bootstrap'; ++import { UserDlgProps, UserDlgState } from './cred-dlg-types'; ++import UserCredentialAttrs from '../user-credential-attrs/user-credential-attrs'; ++ ++ ++class CredDlg extends React.Component { ++ constructor(props: UserDlgProps) { ++ super(props); ++ this.sendCommand = this.sendCommand.bind(this); ++ this.toggleModal = this.toggleModal.bind(this); ++ this.state = { ++ Command: {}, ++ Unid: "", ++ ShowModal: false, ++ UserCredential: {} ++ }; ++ this.changeCommandAttrs = React.createRef(); ++ } ++ changeCommandAttrs: any; ++ ++ toggleModal(value: boolean) { ++ this.setState({ ShowModal: value }); ++ } ++ ++ getDefinedUserIDs(userCredential: any) { ++ var users = userCredential.User ++ if (!users) { ++ return []; ++ } ++ return Object.keys(users).map(user_id => { ++ return { label: user_id, id: parseInt(user_id) } ++ }); ++ } ++ ++ getSupportedEnum(enumData: any, supportedEnumField: any) { ++ if (!supportedEnumField) { ++ return enumData; ++ } ++ return enumData.filter((enumItem:any) => supportedEnumField[enumItem.name]); ++ } ++ ++ updateState(unid: string, command: any, showModal: boolean, userCredential: any) { ++ let updatedCommand = structuredClone(command); ++ ++ updatedCommand.fields = command.fields.map( (field: any) => { ++ switch (field.name) { ++ case "UserUniqueID": ++ field.values = this.getDefinedUserIDs(userCredential); ++ if (field.values.length !== 0) { ++ field.defaultValue = field.values[0]; ++ field.default = field.values[0].id; ++ } ++ break; ++ case "CredentialType": ++ field.enum = this.getSupportedEnum(field.enum, userCredential.SupportedCredentialTypes?.Reported); ++ break; ++ } ++ return field; ++ }); ++ ++ ++ updatedCommand.UserList = userCredential.User; ++ updatedCommand.UserCredential = userCredential; ++ ++ this.setState({ Unid: unid, Command: updatedCommand, ShowModal: showModal, UserCredential: userCredential }, ++ () => { ++ this.changeCommandAttrs.current.updateState(this.state.Command) ++ }); ++ ++ } ++ ++ sendCommand() { ++ if (this.state.UserCredential !== undefined) ++ this.props.SocketServer.send(JSON.stringify( ++ { ++ type: "run-cluster-command", ++ data: { ++ Unid: this.state.Unid, ++ ClusterType: "UserCredential", ++ Cmd: this.state.Command.name, ++ Payload: this.changeCommandAttrs.current.state.Payload ++ } ++ })); ++ } ++ ++ ++ render() { ++ return ( ++ this.toggleModal(false)}> ++ ++ {this.state.Command.name} ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ); ++ } ++} ++ ++export default CredDlg +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-attrs/user-credential-attrs.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-attrs/user-credential-attrs.tsx +new file mode 100644 +index 0000000000..005cca3dd1 +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-attrs/user-credential-attrs.tsx +@@ -0,0 +1,244 @@ ++import * as React from 'react'; ++import { Card, Form } from 'react-bootstrap'; ++import * as FiIcons from 'react-icons/fi'; ++import { Autocomplete, FormControlLabel, InputAdornment, MenuItem, Switch, TextField, Tooltip } from '@mui/material'; ++import CommandAttrs from '../../../components/command-atts/command-attrs'; ++ ++class UserCredentialAttrs extends CommandAttrs { ++ constructor(props: {}) { ++ super(props); ++ } ++ ++ ++ // If the command is trying to modify a user or credential, we update the payload with the current data ++ // Otherwise we only update the payload UserUniqueID ++ updatePayloadBasedOnUserData(userID : any, payload: any, commandName: string, userList: any, credentialType: any, credentialSlot: any) { ++ if (!userList) { ++ return payload; ++ } ++ ++ let modifyCommand = commandName.includes("Modify"); ++ let credentialCommand = commandName.includes("Credential"); ++ ++ if (modifyCommand) { ++ let user = userList[userID]; ++ if (credentialCommand) { ++ const userCred = user.Credential || {}; ++ const credType = userCred[credentialType] || {}; ++ const credSlot = credType[credentialSlot] || {}; ++ const credData = credSlot.CredentialData?.Reported || ""; ++ if (credData) { ++ payload.CredentialData = credData; ++ } else { ++ payload.CredentialData = ""; ++ } ++ } else { ++ Object.keys(payload).forEach((key) => { ++ if (user[key]) { ++ payload[key] = user[key].Reported; ++ } ++ }); ++ } ++ } ++ ++ return payload; ++ } ++ ++ ++ updateCredentials(userUniqueId: any, credentialType: any, userList: any, currentPayload: any, command: any) { ++ var slotItem = command.fields.find((item: any) => item.name === "CredentialSlot"); ++ if (!slotItem) ++ return currentPayload; ++ ++ if (command.name.includes("Add")) { ++ slotItem.values = this.getAvailableSlots(command.UserCredential, userUniqueId, credentialType); ++ } else { ++ slotItem.values = this.getDefinedSlots(command.UserCredential, userUniqueId, credentialType); ++ } ++ const credentialSlot = slotItem.values[0]?.id || '' ++ let newPayload = this.updatePayloadBasedOnUserData(currentPayload.UserUniqueID, currentPayload, command.name, ++ userList, credentialType, credentialSlot); ++ newPayload["CredentialSlot"] = credentialSlot; ++ newPayload["CredentialType"] = credentialType; ++ ++ return newPayload; ++ } ++ // Called when the User ID changes in the modal ++ onValueChange(valueObject: any, name: string) { ++ if (!valueObject) { ++ return; ++ } ++ ++ let commandName = this.state.Command?.name; ++ let userList = this.state.Command?.UserList; ++ let currentPayload = this.state.Payload; ++ const rawValue = valueObject.value?.id || valueObject.id; ++ ++ if (!commandName || !userList) { ++ return; ++ } ++ ++ let newPayload = []; ++ switch(name) { ++ case "UserUniqueID": ++ if (commandName.includes("Credential")) { ++ newPayload = this.updateCredentials(rawValue, this.state.Payload.CredentialType, userList, currentPayload, this.state.Command); ++ } ++ ++ // Update the payload based on the user ID ++ newPayload = this.updatePayloadBasedOnUserData(rawValue, newPayload.length == 0 ? currentPayload : newPayload, commandName, userList, currentPayload.CredentialType, currentPayload.CredentialSlot); ++ ++ newPayload["UserUniqueID"] = rawValue; ++ this.setState({ Payload: newPayload }); ++ break; ++ case "CredentialType": ++ const userUniqueId = this.state.Payload.UserUniqueID; ++ const credentialType = rawValue; ++ newPayload = this.updateCredentials(userUniqueId, credentialType, userList, currentPayload, this.state.Command); ++ // Needed in case we don't have a CredentialSlot/UserId field ++ newPayload["CredentialType"] = credentialType; ++ this.setState({ Payload: newPayload, Command: this.state.Command }); ++ break; ++ case "CredentialSlot": ++ const credentialSlot = rawValue; ++ newPayload = this.updatePayloadBasedOnUserData(currentPayload.UserUniqueID, currentPayload, commandName, userList, currentPayload.CredentialType, credentialSlot); ++ newPayload["CredentialSlot"] = credentialSlot; ++ this.setState({ Payload: newPayload }); ++ break; ++ } ++ } ++ ++ getAutocompleteValue(payloadValue:any) { ++ return {label: payloadValue+"", id: payloadValue}; ++ } ++ ++ getAvailableSlots(userCredentials: any, currentUserID: any, credentialType: any) { ++ ++ var availableSlot = []; ++ var credentialTypeName = credentialType || "default"; ++ var currentCredentialRule = userCredentials.Credentials[credentialTypeName] || {}; ++ var maxSlot = currentCredentialRule.SupportedSlotCount?.Reported || 10; ++ var userObject = userCredentials.User || {}; ++ var credentials = userObject[currentUserID]?.Credential || {}; ++ var currentUserSlots = credentials[credentialType] || {}; ++ ++ for (let i = 1; i <= maxSlot; i++) { ++ if (currentUserSlots[i] === undefined) { ++ availableSlot.push({label: i +"", id: i}); ++ } ++ } ++ ++ return availableSlot; ++ } ++ getDefinedSlots(userCredential: any, currentUserID: any, credentialType: any) { ++ var userObject = userCredential.User || {}; ++ var credentials = userObject[currentUserID]?.Credential || {}; ++ var currentUserSlots = credentials[credentialType] || {}; ++ ++ return Object.keys(currentUserSlots).map( (slot_id) => ({label: slot_id +"", id: parseInt(slot_id)})) ++ } ++ ++ ++ // This is the default payload for the command ++ // We update it if we are modifying something ++ getPayload(command: any) { ++ let payload = super.getPayload(command); ++ ++ ++ if (command.name.includes("Credential")) { ++ payload = this.updateCredentials(payload.UserUniqueID, payload.CredentialType, command.UserList, payload, command); ++ } ++ ++ return this.updatePayloadBasedOnUserData(payload.UserUniqueID, payload, command.name, command.UserList, payload.CredentialType, payload.CredentialSlot); ++ } ++ ++ renderField = (item: any, payload: any, prefixNames: any[], index: any) => { ++ var validationRegex = "" ++ // Expire timeout minutes is only for DuressUser ++ if (item.name === "ExpiringTimeoutMinutes" && this.state.Payload?.UserType !== "DuressUser") { ++ return; ++ } ++ if ((item.name === "CredentialData" ++ && this.state.Payload?.CredentialType === "PINCode") || ++ item.name === "PINCode") { ++ validationRegex = "^[0-9]*$"; ++ } ++ ++ switch (item.type) { ++ case "number": ++ if (item.values) { ++ return ( ++
++ this.onValueChange({value}, item.name)} ++ renderInput={(params) => } ++ /> ++
++ ) ++ } ++ break; ++ case "boolean": ++ return ( ++
++
++
++ } label={item.name} name={item.name} onChange={this.handleChange.bind(this, prefixNames, true, false)} /> ++
++
++
++ ) ++ case "enum": ++ if (item.enum && item.enum.length) { ++ return ( ++
++ { ++ if (item.name == "CredentialType") { ++ this.onValueChange({id: event.target.value}, item.name); ++ } else { ++ this.handleChange(prefixNames, false, false, event) ++ } ++ } ++ } ++ variant="outlined"> ++ {item.enum.map((j: any, ind: number) => { ++ return ++ {j.name} ++ ++ })} ++ ++
++ ) ++ } ++ break; ++ } ++ return (
++ { ++ if (validationRegex !== "") { ++ if (!event.target.value.match(validationRegex)) { ++ return; ++ } ++ } ++ if (item.maxLength && item.maxLength < event.target.value.length) { ++ return ++ } ++ this.handleChange(prefixNames, false, item.type === "number", event) ++ }} ++ onFocus={(event: any) => event.target.select()} inputProps={ ++ { readOnly: this.state.ReadOnly } ++ } /> ++
) ++ } ++} ++ ++export default UserCredentialAttrs +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-types.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-types.tsx +new file mode 100644 +index 0000000000..f1a2d96e13 +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential-types.tsx +@@ -0,0 +1,10 @@ ++export type UserCredentialProps = { ++ NodeList: any, ++ SocketServer: WebSocket, ++ IsConnected: boolean | null ++} ++ ++export type UserCredentialState = { ++ List: Map, ++ IsAllExpanded: boolean ++} +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx +new file mode 100644 +index 0000000000..0c0881ca1a +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx +@@ -0,0 +1,326 @@ ++import React, { Fragment } from 'react'; ++import * as FiIcons from 'react-icons/fi'; ++import * as BsIcons from 'react-icons/bs'; ++import * as RiIcons from 'react-icons/ri'; ++import { Button, Col, Dropdown, DropdownButton, Row, Table, Badge, Modal} from 'react-bootstrap'; ++import * as CgIcons from 'react-icons/cg'; ++import { Link } from 'react-router-dom'; ++import { UserCredentialProps, UserCredentialState } from './user-credential-types'; ++import EditableAttribute from '../../components/editable-attribute/editable-attribute'; ++import UserDlg from './user-dlg/user-dlg'; ++import CredDlg from './cred-dlg/cred-dlg'; ++import { ClusterTypeAttrs } from '../../cluster-types/cluster-type-attributes'; ++import { Tooltip } from '@mui/material'; ++ ++ ++export class UserCredential extends React.Component { ++ constructor(props: UserCredentialProps) { ++ super(props); ++ this.state = { ++ List: this.getList(this.props.NodeList), ++ IsAllExpanded: false ++ } ++ this.userCommandDlg = React.createRef(); ++ this.credCommandDlg = React.createRef(); ++ } ++ ++ userCommandDlg: any; ++ credCommandDlg: any; ++ UserCredentialType = "UserCredential"; ++ ++ // https://stackoverflow.com/questions/45167565/does-react-js-support-html5-datalist ++ // Datalist ? ++ // https://stackoverflow.com/questions/57401738/how-to-make-react-input-a-text-and-select ++ // Use custom modal and preSendCommand to send MQTT command ++ ++ preSendCommand(unid: string, endPoint: string, cmd: string) { ++ let command = ClusterTypeAttrs[this.UserCredentialType].server.commands.find((i: { name: string; }) => i.name === cmd); ++ if (!command) ++ return; ++ ++ if (command && command.fields && command.fields.length) { ++ let userCredential = this.state.List.get(unid + endPoint)?.UserCredential ++ // Order matter here, a credential command should display the credCommandDlg even if it contains "user" ++ if (command.name.includes("Credential") || command.name.includes("PIN")) { ++ this.credCommandDlg.current.updateState(`${unid}/${endPoint}`, command, true, userCredential); ++ } else if (command.name.includes("User")) { ++ this.userCommandDlg.current.updateState(`${unid}/${endPoint}`, command, true, userCredential); ++ } ++ } else ++ this.props.SocketServer.send(JSON.stringify( ++ { ++ type: "run-cluster-command", ++ data: { ++ Unid: `${unid}/${endPoint}`, ++ ClusterType: this.UserCredentialType, ++ Cmd: command.name, ++ Payload: {} ++ } ++ })); ++ } ++ ++ updateState(nodeList: any) { ++ this.setState({ List: this.getList(nodeList) }); ++ } ++ ++ getList(nodeList: any) { ++ let list = new Map(); ++ nodeList.forEach((item: any) => { ++ if (!item.ep) ++ return; ++ Object.keys(item.ep).forEach(ep => { ++ if (!item.ep[ep].Clusters?.UserCredential) ++ return; ++ let userCredential = item.ep[ep].Clusters?.UserCredential?.Attributes; ++ console.log("UserCredential : ", userCredential); ++ list.set(item.Unid + ep, { ++ Node: item, ++ EndPoint: ep, ++ UserCredential: userCredential, ++ IsExpanded: (this.state && this.state.List && this.state.List.get(item.Unid + ep)?.IsExpanded) ?? userCredential?.length < 3 ++ }); ++ }); ++ }); ++ return list; ++ } ++ ++ getUsersHeaders = () => { ++ return ( ++ UID ++ User Name ++ User Type ++ Credential Rule ++ User Active ++ ) ++ } ++ getUsersContents = (user_id: number, user: any) => { ++ return ( ++ <> ++ ++ {["Modifier Type : " + user.UserModifierType?.Reported ,
,"Modifier Node ID : " + user.UserModifierNodeId?.Reported]}}> ++ {user_id} ++ ++ ++ ++ ++ {user.UserName?.Reported} ++ ++ ++ ++ ++ {user.UserType?.Reported} ++ ++ ++ {user.CredentialRule?.Reported} ++ {user.UserActiveState?.Reported == 1 ? Active : Inactive} ++ ++ ); ++ } ++ ++ getBadges = (value: any) => { ++ return (value != null ?
++ {Object.entries(value).map( ([key, value]) => { ++ return value ? {key} : ''; ++ })} ++
++ : "-"); ++ } ++ getSupportedCredentialType(credentialsTypes: any, credentialRules: any) { ++ return (credentialsTypes != null ?
++ {Object.entries(credentialsTypes).map(([credentialsType, supported]) => { ++ var currentCredentialRule = credentialRules[credentialsType] || {}; ++ var learnSupport = currentCredentialRule.LearnSupport?.Reported; ++ var supportedSlotCount = currentCredentialRule.SupportedSlotCount?.Reported; ++ var credMinLength = currentCredentialRule.CredentialMinLength?.Reported; ++ var credMaxLength = currentCredentialRule.CredentialMaxLength?.Reported; ++ ++ return supported ? ( ++ ++ , "Supported Slot Count : " + supportedSlotCount,
, "Credential Min Length : " + credMinLength,
, "Credential Max Length : " + credMaxLength]}> ++ {credentialsType} ++ ++ ) ++ : ''; ++ })} ++
++ : "-"); ++ } ++ ++ getCredentialsTable = (credential : any) => { ++ if (Object.keys(credential).length === 0) { ++ return (Not credential found) ++ } ++ return ( ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ { ++ Object.entries(credential).map(([credentialType, slots], index) => { ++ var slotObjects = slots as object; ++ var slotCount = Object.keys(slotObjects).length; ++ return ( ++ <> ++ { ++ Object.entries(slotObjects).map(([slotID, slotData], index) => { ++ return (<> ++ ++ { index === 0 ? : <>} ++ ++ ++ ++ ++ ++ ) ++ }) ++ } ++ ++ ) ++ })} ++ ++
Credential TypeCredential SlotCRBCredential Data
{credentialType} ++ {["Modifier Type : " + slotData.CredentialModifierType?.Reported,
, "Modifier Node ID : " + slotData.CredentialModifierNodeId?.Reported]}}> ++ {slotID} ++ ++ 		{slotData.CredentialReadBack?.Reported ? : } {slotData.CredentialData?.Reported}
++ ++ ) ++ } ++ ++ toggleIsAllExpanded = () => { ++ this.state.List.forEach((value: any, key: string) => { ++ value.IsExpanded = !this.state.IsAllExpanded; ++ }); ++ this.setState({ IsAllExpanded: !this.state.IsAllExpanded }); ++ } ++ ++ render() { ++ return ( ++ <> ++

User Credential

++ {(this.state.List.size === 0 || !this.props.IsConnected) ++ ? ++ ++ No Content ++ ++ ++ : ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ {[...this.state.List.values()].map((item: any, index: number) => { ++ ++ let isOffline = item.Node.NetworkStatus === "Offline" || item.Node.NetworkStatus === "Unavailable"; ++ let commands = item.Node.ep[item.EndPoint].Clusters.UserCredential.SupportedCommands && item.Node.ep[item.EndPoint].Clusters.UserCredential.SupportedCommands.filter((cmd: any) => cmd !== "WriteAttributes"); ++ let userList = item.UserCredential?.User || {}; ++ let userCount = Object.keys(userList).length; ++ return ( ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ {userCount && item.IsExpanded ++ ? ++ ( ++ ++ ) ++ : ++ } ++ ++ ++ ) ++ })} ++ ++
++ ++ {this.state.IsAllExpanded ? : } ++ ++ NodeMax UsersSupported User TypesSupported Credential TypesSupported Credential RulesSupported Commands
++ { item.IsExpanded = !item.IsExpanded; }} hidden={!userCount}> ++ {item.IsExpanded ? : } ++ ++ ++ {item.UserCredential?.SupportedUserUniqueIdentifiers?.Reported}{this.getBadges(item.UserCredential?.SupportedUserTypes?.Reported)}{this.getSupportedCredentialType(item.UserCredential?.SupportedCredentialTypes?.Reported, item.UserCredential?.Credentials)}{this.getBadges(item.UserCredential?.SupportedCredentialRules?.Reported)} ++ {commands && commands.length ++ ? ++ {commands.map((cmd: string, cmdIndex: number) => { ++ return ( ++ {cmd} ++ ) ++ }) ++ } ++ ++ : <>} ++
++ ++ ++ {this.getUsersHeaders()} ++ ++ ++ {Object.entries(userList).map((user: any, indexParam: number) => { ++ var userId = user[0]; ++ var userObject = user[1]; ++ ++ if (!userObject) { ++ return; ++ } ++ ++ var credentials = userObject.Credential || {}; ++ ++ return ( ++ <> ++ ++ {this.getUsersContents(userId, userObject)} ++ ++ {this.getCredentialsTable(credentials)} ++ ++ ) ++ }) ++ } ++ ++ ++
++ 		User Count: {userCount}
++ } ++ ++ ++ ++ ++ ++ ++ ) ++ }; ++} ++ ++export default UserCredential; +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg-types.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg-types.tsx +new file mode 100644 +index 0000000000..76e9c0e53e +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg-types.tsx +@@ -0,0 +1,10 @@ ++export type UserDlgState = { ++ Command: any, ++ Unid: any, ++ ShowModal: boolean, ++ UserCredential: any ++} ++ ++export type UserDlgProps = { ++ SocketServer: WebSocket ++} +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg.tsx +new file mode 100644 +index 0000000000..7b04cff24e +--- /dev/null ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-dlg/user-dlg.tsx +@@ -0,0 +1,130 @@ ++import * as React from 'react'; ++import { Button, Modal } from 'react-bootstrap'; ++import { UserDlgProps, UserDlgState } from './user-dlg-types'; ++import UserCredentialAttrs from '../user-credential-attrs/user-credential-attrs'; ++ ++ ++class UserDlg extends React.Component { ++ constructor(props: UserDlgProps) { ++ super(props); ++ this.sendCommand = this.sendCommand.bind(this); ++ this.toggleModal = this.toggleModal.bind(this); ++ this.state = { ++ Command: {}, ++ Unid: "", ++ ShowModal: false, ++ UserCredential: {} ++ }; ++ this.changeCommandAttrs = React.createRef(); ++ } ++ changeCommandAttrs: any; ++ ++ toggleModal(value: boolean) { ++ this.setState({ ShowModal: value }); ++ } ++ ++ getAvailableUserID(userCredential: any) { ++ let availableUserID = [] ++ var users = userCredential.User || {} ++ let maxUsers = userCredential.SupportedUserUniqueIdentifiers.Reported; ++ for (let i = 1; i <= maxUsers; i++) { ++ if (users[i] === undefined) { ++ availableUserID.push({label: i +"", id: i}); ++ } ++ } ++ ++ return availableUserID; ++ } ++ ++ getDefinedUserIDs(userCredential: any) { ++ var users = userCredential.User ++ if (!users) { ++ return []; ++ } ++ return Object.keys(users).map(user_id => { ++ return { label: user_id, id: parseInt(user_id) } ++ }); ++ } ++ ++ getSupportedEnum(enumData: any, supportedEnumField: any) { ++ if (!supportedEnumField) { ++ return enumData; ++ } ++ return enumData.filter((enumItem:any) => supportedEnumField[enumItem.name]); ++ } ++ ++ updateState(unid: string, command: any, showModal: boolean, userCredential: any) { ++ let updatedCommand = structuredClone(command); ++ ++ updatedCommand.fields = command.fields.map( (field: any) => { ++ switch (field.name) { ++ case "UserUniqueID": ++ if (command.name.includes("Add")) { ++ field.values = this.getAvailableUserID(userCredential); ++ } else { ++ field.values = this.getDefinedUserIDs(userCredential); ++ } ++ if (field.values.length !== 0) { ++ field.defaultValue = field.values[0]; ++ field.default = field.values[0].id; ++ } ++ break; ++ case "UserType": ++ field.enum = this.getSupportedEnum(field.enum, userCredential.SupportedUserTypes?.Reported); ++ break; ++ case "CredentialRule": ++ field.enum = this.getSupportedEnum(field.enum, userCredential.SupportedCredentialRules?.Reported); ++ break; ++ case "UserActiveState": ++ field.default = true; ++ break; ++ } ++ return field; ++ }); ++ ++ updatedCommand.UserList = userCredential.User; ++ ++ this.setState({ Unid: unid, Command: updatedCommand, ShowModal: showModal, UserCredential: userCredential }, ++ () => { ++ this.changeCommandAttrs.current.updateState(this.state.Command) ++ }); ++ ++ } ++ ++ sendCommand() { ++ if (this.state.UserCredential !== undefined) ++ this.props.SocketServer.send(JSON.stringify( ++ { ++ type: "run-cluster-command", ++ data: { ++ Unid: this.state.Unid, ++ ClusterType: "UserCredential", ++ Cmd: this.state.Command.name, ++ Payload: this.changeCommandAttrs.current.state.Payload ++ } ++ })); ++ } ++ ++ render() { ++ return ( ++ this.toggleModal(false)}> ++ ++ {this.state.Command.name} ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ); ++ } ++} ++ ++export default UserDlg +\ No newline at end of file +diff --git a/applications/dev_ui/dev_gui/zap/addon-helper.js b/applications/dev_ui/dev_gui/zap/addon-helper.js +index aa013c9f1a..5fcd8c22bb 100644 +--- a/applications/dev_ui/dev_gui/zap/addon-helper.js ++++ b/applications/dev_ui/dev_gui/zap/addon-helper.js +@@ -32,7 +32,8 @@ const supportedClusters = [ + "TemperatureMeasurement", + "Thermostat", + "WindSpeedMeasurement", +- "WindowCovering" ++ "WindowCovering", ++ "UserCredential" + ]; + + let enums = new Set(); +-- +2.39.5 + diff --git a/patches/UnifySDK/0010-UIC-3222-Allow-to-change-parent-of-a-node.patch b/patches/UnifySDK/0010-UIC-3222-Allow-to-change-parent-of-a-node.patch new file mode 100644 index 000000000..09f101efb --- /dev/null +++ b/patches/UnifySDK/0010-UIC-3222-Allow-to-change-parent-of-a-node.patch @@ -0,0 +1,252 @@ +From 26b2357b1717410056a68f093696d99c65997034 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Tue, 3 Sep 2024 11:51:18 +0200 +Subject: [PATCH] UIC-3222: Allow to change parent of a node + +This utility function will allow us to implement UUIC association with ease +--- + .../uic_attribute_store/include/attribute.hpp | 5 ++ + .../include/attribute_store.h | 14 +++ + .../src/attribute_store.cpp | 21 +++++ + .../src/attribute_store_node.cpp | 29 ++++++ + .../src/attribute_store_node.h | 11 +++ + .../test/attribute_store_cpp_wrap_test.cpp | 90 +++++++++++++++++++ + 6 files changed, 170 insertions(+) + +diff --git a/components/uic_attribute_store/include/attribute.hpp b/components/uic_attribute_store/include/attribute.hpp +index 466ad9ffef..b30947a68b 100644 +--- a/components/uic_attribute_store/include/attribute.hpp ++++ b/components/uic_attribute_store/include/attribute.hpp +@@ -504,6 +504,11 @@ class attribute + _n = ATTRIBUTE_STORE_INVALID_NODE; + } + ++ sl_status_t change_parent(attribute new_parent) ++ { ++ return attribute_store_change_parent(this->_n, new_parent); ++ } ++ + /** + * @brief Visit all nodes in the tree. + * +diff --git a/components/uic_attribute_store/include/attribute_store.h b/components/uic_attribute_store/include/attribute_store.h +index 59dfe10db7..288999918e 100644 +--- a/components/uic_attribute_store/include/attribute_store.h ++++ b/components/uic_attribute_store/include/attribute_store.h +@@ -505,6 +505,20 @@ uint8_t attribute_store_get_node_value_size( + sl_status_t attribute_store_refresh_node_and_children_callbacks( + attribute_store_node_t node); + ++/** ++ * @brief Change parent of node to the new parent. ++ * ++ * @note The parent node must be a valid node in the attribute store. ++ * @note The new parent should have the type than the node current parent ++ * ++ * @param node The node handle of the node to change parent ++ * @param new_parent The node handle of the new parent ++ * ++ * @return SL_STATUS_OK if the parent was changed successfully, SL_STATUS_FAIL otherwise ++ */ ++sl_status_t attribute_store_change_parent(attribute_store_node_t node, ++ attribute_store_node_t new_parent); ++ + /** + * @brief Log the content of the Attribute Store tree using \ref sl_log. + */ +diff --git a/components/uic_attribute_store/src/attribute_store.cpp b/components/uic_attribute_store/src/attribute_store.cpp +index ed5a6a333a..043141d875 100644 +--- a/components/uic_attribute_store/src/attribute_store.cpp ++++ b/components/uic_attribute_store/src/attribute_store.cpp +@@ -158,6 +158,27 @@ static attribute_store_node * + return found_node; + } + ++sl_status_t attribute_store_change_parent(attribute_store_node_t node, ++ attribute_store_node_t new_parent) ++{ ++ auto base_node = attribute_store_get_node_from_id(node); ++ if (base_node == NULL) { ++ sl_log_error(LOG_TAG, "Node %d not found in the attribute store.", node); ++ return SL_STATUS_FAIL; ++ } ++ auto parent_node = attribute_store_get_node_from_id(new_parent); ++ if (parent_node == NULL) { ++ sl_log_error(LOG_TAG, ++ "Parent node %d not found in the attribute store.", ++ new_parent); ++ return SL_STATUS_FAIL; ++ } ++ ++ return base_node->change_parent(parent_node) != NULL ? SL_STATUS_OK ++ : SL_STATUS_FAIL; ++} ++ ++ + /** + * @brief Compares if a node value is identical to the value/value size + * +diff --git a/components/uic_attribute_store/src/attribute_store_node.cpp b/components/uic_attribute_store/src/attribute_store_node.cpp +index de96b58a30..437a5d6bc7 100644 +--- a/components/uic_attribute_store/src/attribute_store_node.cpp ++++ b/components/uic_attribute_store/src/attribute_store_node.cpp +@@ -93,6 +93,35 @@ attribute_store_node *attribute_store_node::find_id(attribute_store_node_t _id) + return NULL; + } + ++attribute_store_node* ++ attribute_store_node::change_parent(attribute_store_node* new_parent) ++{ ++ if (new_parent == NULL) { ++ sl_log_warning(LOG_TAG, "Cannot change parent to a NULL node."); ++ return NULL; ++ } ++ ++ if (new_parent == this->parent_node) { ++ sl_log_warning(LOG_TAG, "Cannot change parent to the same node."); ++ return NULL; ++ } ++ ++ if (new_parent->type != this->parent_node->type) { ++ sl_log_warning(LOG_TAG, ++ "Cannot change parent to a node of different type. " ++ "New Parent type: %s, Old parent type: %s", ++ attribute_store_get_type_name(new_parent->type), ++ attribute_store_get_type_name(this->parent_node->type)); ++ return NULL; ++ } ++ // Clear old parent child link ++ this->parent_node->remove_child_link(this); ++ ++ new_parent->child_nodes.push_back(this); ++ this->parent_node = new_parent; ++ return new_parent; ++} ++ + /////////////////////////////////////////////////////////////////////////////// + // Log functions + /////////////////////////////////////////////////////////////////////////////// +diff --git a/components/uic_attribute_store/src/attribute_store_node.h b/components/uic_attribute_store/src/attribute_store_node.h +index c840746904..63d0a2b247 100644 +--- a/components/uic_attribute_store/src/attribute_store_node.h ++++ b/components/uic_attribute_store/src/attribute_store_node.h +@@ -109,6 +109,17 @@ class attribute_store_node + */ + attribute_store_node *find_id(attribute_store_node_t _id); + ++ /** ++ * @brief Change the parent node to new_parent ++ * ++ * @note The new parent must be of the same type as the current parent ++ * ++ * @param new_parent The new parent node to assign to the current node ++ * ++ * @returns The new parent node if the operation was successful, NULL otherwise ++ */ ++ attribute_store_node *change_parent(attribute_store_node* new_parent); ++ + /** + * @brief Logs the content of the a Node using \ref sl_log + */ +diff --git a/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp b/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp +index d578608021..0def92ab15 100644 +--- a/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp ++++ b/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp +@@ -246,4 +246,94 @@ void test_attribute_store_cpp_wrap_emplace_happy_case() + "Should have created a new node"); + } + ++void test_attribute_store_change_parent_happy_case() ++{ ++ /* A ++ * / \ ++ * B B ++ * / \ ++ * C D ++*/ ++ ++ attribute a = attribute::root().add_node('A'); ++ attribute b1 = a.add_node('B'); ++ attribute b2 = a.add_node('B'); ++ attribute c = b1.add_node('C'); ++ attribute d = b1.add_node('D'); ++ ++ c.set_reported(55); ++ d.set_reported(42); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, d.change_parent(b2), "Change parent should have worked"); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(1, b1.child_count(), "B1 should only have 1 child now"); ++ TEST_ASSERT_EQUAL_MESSAGE(1, b2.child_count(), "B2 should have 1 child now"); ++ TEST_ASSERT_EQUAL_MESSAGE(d, b2.child(0), "D should be the only child of B2"); ++ TEST_ASSERT_EQUAL_MESSAGE(d.parent(), b2, "D should have B2 as parent"); ++ TEST_ASSERT_EQUAL_MESSAGE(42, ++ d.reported(), ++ "D should have 42 as reported value"); ++} ++ ++void test_attribute_store_change_parent_not_same_parent_type() ++{ ++ /* A ++ * / \ ++ * B E ++ * / \ ++ * C D ++*/ ++ ++ attribute a = attribute::root().add_node('A'); ++ attribute b = a.add_node('B'); ++ attribute e = a.add_node('E'); ++ attribute c = b.add_node('C'); ++ attribute d = b.add_node('D'); ++ ++ c.set_reported(55); ++ d.set_reported(42); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, ++ d.change_parent(e), ++ "Change parent should NOT have worked"); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(2, b.child_count(), "B should still have 2 child"); ++ TEST_ASSERT_EQUAL_MESSAGE(0, e.child_count(), "E should not have any child"); ++ TEST_ASSERT_EQUAL_MESSAGE(d.parent(), b, "D should have B as parent"); ++ TEST_ASSERT_EQUAL_MESSAGE(42, ++ d.reported(), ++ "D should have 42 as reported value"); ++} ++ ++ ++void test_attribute_store_change_parent_not_same_parent() ++{ ++ /* A ++ * / \ ++ * B E ++ * / \ ++ * C D ++*/ ++ ++ attribute a = attribute::root().add_node('A'); ++ attribute b = a.add_node('B'); ++ attribute e = a.add_node('E'); ++ attribute c = b.add_node('C'); ++ attribute d = b.add_node('D'); ++ ++ c.set_reported(55); ++ d.set_reported(42); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, ++ d.change_parent(b), ++ "Change parent should NOT have worked"); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(2, b.child_count(), "B should still have 2 child"); ++ TEST_ASSERT_EQUAL_MESSAGE(0, e.child_count(), "E should not have any child"); ++ TEST_ASSERT_EQUAL_MESSAGE(d.parent(), b, "D should have B as parent"); ++ TEST_ASSERT_EQUAL_MESSAGE(42, ++ d.reported(), ++ "D should have 42 as reported value"); ++} ++ + } // extern "C" +-- +2.39.5 + diff --git a/patches/UnifySDK/0011-UIC-3222-Allow-to-send-toast-to-the-UI.patch b/patches/UnifySDK/0011-UIC-3222-Allow-to-send-toast-to-the-UI.patch new file mode 100644 index 000000000..b1279e6aa --- /dev/null +++ b/patches/UnifySDK/0011-UIC-3222-Allow-to-send-toast-to-the-UI.patch @@ -0,0 +1,108 @@ +From f0461681f727a3be5e6cc751f9ec369b3c6d5e9b Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Tue, 10 Sep 2024 15:41:30 +0200 +Subject: [PATCH] UIC-3222: Allow to send toast to the UI + +Sending data over ucl/Event can display a message in the DevUI +--- + applications/dev_ui/dev_gui/src/App.tsx | 20 +++++++++++++++++++ + .../dev_ui/dev_gui/src/dev-gui-api/handler.js | 16 ++++++++++++++- + .../dev_ui/dev_gui/src/dev-gui-api/main.js | 5 ++++- + 3 files changed, 39 insertions(+), 2 deletions(-) + +diff --git a/applications/dev_ui/dev_gui/src/App.tsx b/applications/dev_ui/dev_gui/src/App.tsx +index 92e17f0c9a..5b8673baf8 100644 +--- a/applications/dev_ui/dev_gui/src/App.tsx ++++ b/applications/dev_ui/dev_gui/src/App.tsx +@@ -148,6 +148,23 @@ class App extends Component<{}, AppState> { + this.setState({ CommissionableDevices: list }); + } + ++ handleEvents(data: any) { ++ var toastType = toast.TYPE.DEFAULT; ++ switch (data.level) { ++ case 1: ++ toastType = toast.TYPE.INFO; ++ break; ++ case 2: ++ toastType = toast.TYPE.WARNING; ++ break; ++ case 3: ++ case 4: ++ toastType = toast.TYPE.ERROR; ++ break; ++ } ++ toast(data.message, { type: toastType }) ++ } ++ + handleUPTIChange(list: any[]) { + let upti = this.state.UPTI; + upti.List = list; +@@ -412,6 +429,9 @@ class App extends Component<{}, AppState> { + case "commissionable-device": + this.handleCommissionableDevices(mes.data); + break; ++ case "event": ++ this.handleEvents(mes.data); ++ break; + } + } + +diff --git a/applications/dev_ui/dev_gui/src/dev-gui-api/handler.js b/applications/dev_ui/dev_gui/src/dev-gui-api/handler.js +index f24aef987e..784d84c500 100644 +--- a/applications/dev_ui/dev_gui/src/dev-gui-api/handler.js ++++ b/applications/dev_ui/dev_gui/src/dev-gui-api/handler.js +@@ -40,6 +40,20 @@ exports.processSmartStart = (topic, message) => { + } + } + ++exports.processEvent = (topic, message) => { ++ console.log(`Received Event : '${message}'`); ++ if (message.toString() == "") ++ return; ++ try { ++ return { ++ type: "event", ++ data: JSON.parse(message) ++ }; ++ } catch (error) { ++ return getErrorResponse(topic, message, error); ++ } ++} ++ + exports.processCluster = (topic, message) => { + let index = -1; + let match = topic.match(/ucl\/by-unid\/(.*)\/(ep\d+)\/(.*)/) +@@ -678,4 +692,4 @@ exports.addToQueue = addToQueue; + exports.runQueueHandler = runQueueHandler; + exports.getErrorResponse = getErrorResponse; + exports.clients = clients; +-exports.state = state; +\ No newline at end of file ++exports.state = state; +diff --git a/applications/dev_ui/dev_gui/src/dev-gui-api/main.js b/applications/dev_ui/dev_gui/src/dev-gui-api/main.js +index 43e80e8dc5..4d829d972f 100644 +--- a/applications/dev_ui/dev_gui/src/dev-gui-api/main.js ++++ b/applications/dev_ui/dev_gui/src/dev-gui-api/main.js +@@ -33,7 +33,8 @@ let topics = ["ucl/SmartStart/List", + "ucl/UPTICap/#", + "ucl/by-machine-id/+/SystemMetrics/SupportedCommands", + "ucl/by-machine-id/+/SystemMetrics/Attributes/#", +- "ucl/by-mqtt-client/+/ApplicationMonitoring/Attributes/#" ++ "ucl/by-mqtt-client/+/ApplicationMonitoring/Attributes/#", ++ "ucl/Event" + ]; + Object.keys(supportedClusters).forEach((i) => { + topics.push(`ucl/by-unid/+/+/${i}/SupportedCommands`); +@@ -282,6 +283,8 @@ function onMqttMessage(topic, message) { + response = handler.processAppMonitoringList(topic, message); + } else if (topic.match(/ucl\/SmartStart\/CommissionableDevice\/(.*)/)) { + response = handler.processCommissionableDevices(topic, message); ++ } else if (topic === "ucl/Event") { ++ response = handler.processEvent(topic, message); + } + if (response && Object.keys(response).length > 0) + handler.addToQueue(response.type, response.data); +-- +2.39.5 + diff --git a/patches/UnifySDK/0012-UIC-3222-Sonar-fixes.patch b/patches/UnifySDK/0012-UIC-3222-Sonar-fixes.patch new file mode 100644 index 000000000..2f358689b --- /dev/null +++ b/patches/UnifySDK/0012-UIC-3222-Sonar-fixes.patch @@ -0,0 +1,58 @@ +From df073d04e9095c28c358600b70bf95e0a68d0969 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Wed, 18 Sep 2024 12:04:41 +0200 +Subject: [PATCH] UIC-3222: Sonar fixes + +--- + .../src/attribute_store_node.cpp | 5 +++++ + .../test/attribute_store_cpp_wrap_test.cpp | 20 +++++++++++++++++++ + 2 files changed, 25 insertions(+) + +diff --git a/components/uic_attribute_store/src/attribute_store_node.cpp b/components/uic_attribute_store/src/attribute_store_node.cpp +index 437a5d6bc7..3610a8f2e4 100644 +--- a/components/uic_attribute_store/src/attribute_store_node.cpp ++++ b/components/uic_attribute_store/src/attribute_store_node.cpp +@@ -96,6 +96,11 @@ attribute_store_node *attribute_store_node::find_id(attribute_store_node_t _id) + attribute_store_node* + attribute_store_node::change_parent(attribute_store_node* new_parent) + { ++ if (this->parent_node == NULL) { ++ sl_log_critical(LOG_TAG, "Cannot change parent of the root node."); ++ return NULL; ++ } ++ + if (new_parent == NULL) { + sl_log_warning(LOG_TAG, "Cannot change parent to a NULL node."); + return NULL; +diff --git a/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp b/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp +index 0def92ab15..dcdccacbed 100644 +--- a/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp ++++ b/components/uic_attribute_store/test/attribute_store_cpp_wrap_test.cpp +@@ -336,4 +336,24 @@ void test_attribute_store_change_parent_not_same_parent() + "D should have 42 as reported value"); + } + ++void test_attribute_store_change_parent_invalids() ++{ ++ attribute root = attribute::root(); ++ attribute a = root.add_node('A'); ++ ++ TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, ++ root.change_parent(a), ++ "Shouldn't be able to change root node parent"); ++ ++ TEST_ASSERT_EQUAL_MESSAGE( ++ SL_STATUS_FAIL, ++ a.change_parent(attribute(0)), ++ "Shouldn't be able to change parent to a invalid node parent"); ++ ++ TEST_ASSERT_EQUAL_MESSAGE( ++ SL_STATUS_FAIL, ++ attribute(0).change_parent(a), ++ "Shouldn't be able to change a invalid node parent"); ++} ++ + } // extern "C" +-- +2.39.5 + diff --git a/patches/UnifySDK/0013-UIC-3222-Admin-PIN-Code-UI.patch b/patches/UnifySDK/0013-UIC-3222-Admin-PIN-Code-UI.patch new file mode 100644 index 000000000..a41a5e634 --- /dev/null +++ b/patches/UnifySDK/0013-UIC-3222-Admin-PIN-Code-UI.patch @@ -0,0 +1,38 @@ +From b3c65f7eb26e2513c5db7d64d0c25cea7cf13500 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Boris=20Labb=C3=A9?= +Date: Mon, 14 Oct 2024 15:53:22 +0200 +Subject: [PATCH] UIC-3222: Admin PIN Code UI + +--- + .../dev_gui/src/pages/user-credential/user-credential.tsx | 8 ++++++++ + 1 file changed, 8 insertions(+) + +diff --git a/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx +index 0c0881ca1a..f1da4f0333 100644 +--- a/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx ++++ b/applications/dev_ui/dev_gui/src/pages/user-credential/user-credential.tsx +@@ -224,6 +224,7 @@ export class UserCredential extends React.ComponentSupported User Types + Supported Credential Types + Supported Credential Rules ++ Admin PIN Code + Supported Commands + + +@@ -251,6 +252,13 @@ export class UserCredential extends React.Component{this.getBadges(item.UserCredential?.SupportedUserTypes?.Reported)} + {this.getSupportedCredentialType(item.UserCredential?.SupportedCredentialTypes?.Reported, item.UserCredential?.Credentials)} + {this.getBadges(item.UserCredential?.SupportedCredentialRules?.Reported)} ++ {(item.UserCredential?.SupportAdminPinCode?.Reported) ? ++ ++ {item.UserCredential?.AdminPinCode?.Reported} ++ ++ : ++ } ++ + + {commands && commands.length + ? +-- +2.39.5 + diff --git a/patches/UnifySDK/0014-UIC-3222-Regenerate-U3C-zap-files-using-latest.patch b/patches/UnifySDK/0014-UIC-3222-Regenerate-U3C-zap-files-using-latest.patch new file mode 100644 index 000000000..6ec0dfc43 --- /dev/null +++ b/patches/UnifySDK/0014-UIC-3222-Regenerate-U3C-zap-files-using-latest.patch @@ -0,0 +1,75283 @@ +From f88d025d3d08adde67977dadf98056213a33c975 Mon Sep 17 00:00:00 2001 +From: Philippe Coval +Date: Wed, 17 Sep 2025 16:45:48 +0200 +Subject: [PATCH] UIC-3222: Regenerate U3C zap files using latest + +Signed-off-by: Philippe Coval +--- + .../src/eed_attribute_store_clusters.c | 32 + + .../src/eed_dotdot_create_clusters.cpp | 87 + + .../include/dotdot_attribute_id_definitions.h | 9 + + .../dotdot_cluster_command_id_definitions.h | 22 + + .../include/dotdot_cluster_id_definitions.h | 4 + + .../zap-generated/include/zap-types.h | 91 + + .../readme_ucl_mqtt_reference.md | 1852 +++++++++- + .../src/dotdot_attribute_id_definitions.c | 79 + + .../src/dotdot_cluster_id_definitions.c | 5 + + .../zap-generated/include/dotdot_mqtt.h | 2588 +++++++------- + .../include/dotdot_mqtt_attributes.h | 780 ++--- + .../zap-generated/src/dotdot_mqtt.cpp | 2244 ++++++------ + .../zap-generated/src/dotdot_mqtt.hpp | 4 +- + .../src/dotdot_mqtt_attributes.cpp | 1592 ++++----- + .../src/dotdot_mqtt_command_helpers.cpp | 1248 +++---- + .../src/dotdot_mqtt_command_helpers.hpp | 480 +-- + .../src/dotdot_mqtt_group_commands.cpp | 10 +- + .../test/dotdot_mqtt_test.include | 514 +-- + .../unify_dotdot_attribute_store_helpers.h | 1560 ++++----- + ...ot_attribute_store_attribute_publisher.cpp | 1556 ++++----- + .../unify_dotdot_attribute_store_helpers.cpp | 3106 ++++++++--------- + ...fy_dotdot_attribute_store_registration.cpp | 2340 ++++++------- + .../test/unify_dotdot_attribute_store_test.c | 1008 +++--- + 23 files changed, 11669 insertions(+), 9542 deletions(-) + +diff --git a/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_attribute_store_clusters.c b/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_attribute_store_clusters.c +index 8780c887c8..05c5b08f6f 100644 +--- a/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_attribute_store_clusters.c ++++ b/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_attribute_store_clusters.c +@@ -2687,6 +2687,38 @@ sl_status_t eed_attribute_store_clusters_init() + &on_zcl_desired_value_update, + DOTDOT_ATTRIBUTE_ID_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS, + DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, ++ DESIRED_ATTRIBUTE); ++ attribute_store_register_callback_by_type_and_state( ++ &on_zcl_desired_value_update, ++ DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE, ++ DESIRED_ATTRIBUTE); + attribute_store_register_callback_by_type_and_state( + &on_zcl_desired_value_update, + DOTDOT_ATTRIBUTE_ID_DESCRIPTOR_DEVICE_TYPE_LIST, +diff --git a/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_dotdot_create_clusters.cpp b/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_dotdot_create_clusters.cpp +index 8230ced6c8..e3ce84ccee 100644 +--- a/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_dotdot_create_clusters.cpp ++++ b/applications/examples/applications/emulated_end_device/components/eed_attribute_store/zap-generated/src/eed_dotdot_create_clusters.cpp +@@ -3990,6 +3990,57 @@ void dotdot_create_configuration_parameters_wrapper(const dotdot_unid_t unid, co + + } + ++void dotdot_create_user_credential_wrapper(const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id){ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_supported_user_unique_identifiers(unid,endpoint_id); ++ if (false == dotdot_user_credential_supported_user_unique_identifiers_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_supported_user_unique_identifiers(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_supported_credential_rules(unid,endpoint_id); ++ if (false == dotdot_user_credential_supported_credential_rules_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_supported_credential_rules(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_supported_credential_types(unid,endpoint_id); ++ if (false == dotdot_user_credential_supported_credential_types_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_supported_credential_types(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_supported_user_types(unid,endpoint_id); ++ if (false == dotdot_user_credential_supported_user_types_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_supported_user_types(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_support_credential_checksum(unid,endpoint_id); ++ if (false == dotdot_user_credential_support_credential_checksum_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_support_credential_checksum(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_support_admin_pin_code(unid,endpoint_id); ++ if (false == dotdot_user_credential_support_admin_pin_code_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_support_admin_pin_code(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_support_admin_pin_code_deactivation(unid,endpoint_id); ++ if (false == dotdot_user_credential_support_admin_pin_code_deactivation_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_support_admin_pin_code_deactivation(unid,endpoint_id,REPORTED_ATTRIBUTE, static_cast(0)); ++ } ++ ++ // Create and set a default value if undefined. ++ dotdot_create_user_credential_admin_pin_code(unid,endpoint_id); ++ if (false == dotdot_user_credential_admin_pin_code_is_reported_defined(unid,endpoint_id)){ ++ dotdot_set_user_credential_admin_pin_code(unid,endpoint_id,REPORTED_ATTRIBUTE, "Dummy value"); ++ } ++ ++} ++ + void dotdot_create_descriptor_wrapper(const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id){ + // Create and set a default value if undefined. + dotdot_create_descriptor_device_type_list(unid,endpoint_id); +@@ -6515,6 +6566,40 @@ void dotdot_unretain_configuration_parameters_wrapper(const dotdot_unid_t unid, + uic_mqtt_dotdot_configuration_parameters_publish_empty_supported_commands(unid, endpoint_id); + } + ++void dotdot_unretain_user_credential_wrapper(const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id){ ++ char base_topic[256]; ++ snprintf(base_topic, sizeof(base_topic), "ucl/by-unid/%s/ep%d", unid, endpoint_id); ++ attribute_store::attribute ep_node = eed_attribute_store_get_endpoint_node(unid, endpoint_id); ++ ++ uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_supported_credential_rules_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_supported_credential_types_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_supported_user_types_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_TYPES).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_support_credential_checksum_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_support_admin_pin_code_deactivation_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION).delete_node(); ++ ++ uic_mqtt_dotdot_user_credential_admin_pin_code_unretain(base_topic,UCL_MQTT_PUBLISH_TYPE_ALL); ++ ep_node.child_by_type(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE).delete_node(); ++ ++ ++ uic_mqtt_dotdot_user_credential_unretain_cluster_revision(base_topic); ++ uic_mqtt_dotdot_user_credential_publish_empty_supported_commands(unid, endpoint_id); ++} ++ + void dotdot_unretain_descriptor_wrapper(const dotdot_unid_t unid, const dotdot_endpoint_id_t endpoint_id){ + char base_topic[256]; + snprintf(base_topic, sizeof(base_topic), "ucl/by-unid/%s/ep%d", unid, endpoint_id); +@@ -6707,6 +6792,7 @@ std::map CreateClusterMap = { + { "Binding", dotdot_create_binding_wrapper }, + { "NameAndLocation", dotdot_create_name_and_location_wrapper }, + { "ConfigurationParameters", dotdot_create_configuration_parameters_wrapper }, ++{ "UserCredential", dotdot_create_user_credential_wrapper }, + { "Descriptor", dotdot_create_descriptor_wrapper }, + { "UnifyFanControl", dotdot_create_unify_fan_control_wrapper }, + { "UnifyThermostat", dotdot_create_unify_thermostat_wrapper }, +@@ -6758,6 +6844,7 @@ std::map CreateUnretainMap = { + { "Binding", dotdot_unretain_binding_wrapper }, + { "NameAndLocation", dotdot_unretain_name_and_location_wrapper }, + { "ConfigurationParameters", dotdot_unretain_configuration_parameters_wrapper }, ++{ "UserCredential", dotdot_unretain_user_credential_wrapper }, + { "Descriptor", dotdot_unretain_descriptor_wrapper }, + { "UnifyFanControl", dotdot_unretain_unify_fan_control_wrapper }, + { "UnifyThermostat", dotdot_unretain_unify_thermostat_wrapper }, +diff --git a/components/uic_dotdot/zap-generated/include/dotdot_attribute_id_definitions.h b/components/uic_dotdot/zap-generated/include/dotdot_attribute_id_definitions.h +index a988971041..b1512d6a82 100644 +--- a/components/uic_dotdot/zap-generated/include/dotdot_attribute_id_definitions.h ++++ b/components/uic_dotdot/zap-generated/include/dotdot_attribute_id_definitions.h +@@ -831,6 +831,15 @@ typedef enum { + #define DOTDOT_NAME_AND_LOCATION_LOCATION_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x1) + // Definitions for cluster: ConfigurationParameters + #define DOTDOT_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x0) ++// Definitions for cluster: UserCredential ++#define DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x0) ++#define DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x1) ++#define DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x2) ++#define DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_TYPES_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x3) ++#define DOTDOT_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x4) ++#define DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x5) ++#define DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x6) ++#define DOTDOT_USER_CREDENTIAL_ADMIN_PIN_CODE_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x7) + // Definitions for cluster: AoXLocator + #define DOTDOT_AOX_LOCATOR_REPORTING_MODE_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x1) + #define DOTDOT_AOX_LOCATOR_POSITION_AND_ORIENTATION_VALID_ATTRIBUTE_ID ((dotdot_attribute_id_t)0x2) +diff --git a/components/uic_dotdot/zap-generated/include/dotdot_cluster_command_id_definitions.h b/components/uic_dotdot/zap-generated/include/dotdot_cluster_command_id_definitions.h +index 7e33175d4a..958a1064f5 100644 +--- a/components/uic_dotdot/zap-generated/include/dotdot_cluster_command_id_definitions.h ++++ b/components/uic_dotdot/zap-generated/include/dotdot_cluster_command_id_definitions.h +@@ -353,6 +353,28 @@ + #define DOTDOT_CONFIGURATION_PARAMETERS_SET_PARAMETER_COMMAND_ID (0x3) + #define DOTDOT_CONFIGURATION_PARAMETERS_DISCOVER_PARAMETER_RANGE_COMMAND_ID (0x4) + ++// Commands for cluster: UserCredential ++#define DOTDOT_USER_CREDENTIAL_ADD_USER_COMMAND_ID (0x1) ++#define DOTDOT_USER_CREDENTIAL_MODIFY_USER_COMMAND_ID (0x2) ++#define DOTDOT_USER_CREDENTIAL_DELETE_USER_COMMAND_ID (0x3) ++#define DOTDOT_USER_CREDENTIAL_ADD_CREDENTIAL_COMMAND_ID (0x4) ++#define DOTDOT_USER_CREDENTIAL_MODIFY_CREDENTIAL_COMMAND_ID (0x5) ++#define DOTDOT_USER_CREDENTIAL_DELETE_CREDENTIAL_COMMAND_ID (0x6) ++#define DOTDOT_USER_CREDENTIAL_DELETE_ALL_USERS_COMMAND_ID (0x7) ++#define DOTDOT_USER_CREDENTIAL_DELETE_ALL_CREDENTIALS_COMMAND_ID (0x8) ++#define DOTDOT_USER_CREDENTIAL_DELETE_ALL_CREDENTIALS_BY_TYPE_COMMAND_ID (0x9) ++#define DOTDOT_USER_CREDENTIAL_DELETE_ALL_CREDENTIALS_FOR_USER_COMMAND_ID (0xA) ++#define DOTDOT_USER_CREDENTIAL_DELETE_ALL_CREDENTIALS_FOR_USER_BY_TYPE_COMMAND_ID (0xB) ++#define DOTDOT_USER_CREDENTIAL_CREDENTIAL_LEARN_START_ADD_COMMAND_ID (0xC) ++#define DOTDOT_USER_CREDENTIAL_CREDENTIAL_LEARN_START_MODIFY_COMMAND_ID (0xD) ++#define DOTDOT_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP_COMMAND_ID (0xE) ++#define DOTDOT_USER_CREDENTIAL_CREDENTIAL_ASSOCIATION_COMMAND_ID (0xF) ++#define DOTDOT_USER_CREDENTIAL_GET_USER_CHECKSUM_COMMAND_ID (0x10) ++#define DOTDOT_USER_CREDENTIAL_GET_CREDENTIAL_CHECKSUM_COMMAND_ID (0x11) ++#define DOTDOT_USER_CREDENTIAL_GET_ALL_USERS_CHECKSUM_COMMAND_ID (0x12) ++#define DOTDOT_USER_CREDENTIAL_SET_ADMIN_PIN_CODE_COMMAND_ID (0x13) ++#define DOTDOT_USER_CREDENTIAL_DEACTIVATE_ADMIN_PIN_CODE_COMMAND_ID (0x14) ++ + // Commands for cluster: AoXLocator + #define DOTDOT_AOX_LOCATOR_IQ_REPORT_COMMAND_ID (0x1) + #define DOTDOT_AOX_LOCATOR_ANGLE_REPORT_COMMAND_ID (0x2) +diff --git a/components/uic_dotdot/zap-generated/include/dotdot_cluster_id_definitions.h b/components/uic_dotdot/zap-generated/include/dotdot_cluster_id_definitions.h +index 34db7d7b79..ee7d429b0f 100644 +--- a/components/uic_dotdot/zap-generated/include/dotdot_cluster_id_definitions.h ++++ b/components/uic_dotdot/zap-generated/include/dotdot_cluster_id_definitions.h +@@ -238,6 +238,10 @@ + #define DOTDOT_CONFIGURATION_PARAMETERS_CLUSTER_ID ((dotdot_cluster_id_t)0xFD07) + + ++// Definitions for cluster: UserCredential ++#define DOTDOT_USER_CREDENTIAL_CLUSTER_ID ((dotdot_cluster_id_t)0xFD08) ++ ++ + // Definitions for cluster: AoXLocator + #define DOTDOT_AOX_LOCATOR_CLUSTER_ID ((dotdot_cluster_id_t)0xFD10) + +diff --git a/components/uic_dotdot/zap-generated/include/zap-types.h b/components/uic_dotdot/zap-generated/include/zap-types.h +index daf85dbdac..9362a37fdc 100644 +--- a/components/uic_dotdot/zap-generated/include/zap-types.h ++++ b/components/uic_dotdot/zap-generated/include/zap-types.h +@@ -508,6 +508,28 @@ typedef enum { + ZCL_COMMISSIONING_STARTUP_CONTROL_JOIN_USING_MAC_ASSOCIATION = 3, + } CommissioningStartupControl; + ++// Enum for CredRule ++typedef enum { ++ ZCL_CRED_RULE_SINGLE = 1, ++ ZCL_CRED_RULE_DUAL = 2, ++ ZCL_CRED_RULE_TRIPLE = 3, ++} CredRule; ++ ++// Enum for CredType ++typedef enum { ++ ZCL_CRED_TYPE_PIN_CODE = 1, ++ ZCL_CRED_TYPE_PASSWORD = 2, ++ ZCL_CRED_TYPE_RFID_CODE = 3, ++ ZCL_CRED_TYPE_BLE = 4, ++ ZCL_CRED_TYPE_NFC = 5, ++ ZCL_CRED_TYPE_UWB = 6, ++ ZCL_CRED_TYPE_EYE_BIOMETRIC = 7, ++ ZCL_CRED_TYPE_FACE_BIOMETRIC = 8, ++ ZCL_CRED_TYPE_FINGER_BIOMETRIC = 9, ++ ZCL_CRED_TYPE_HAND_BIOMETRIC = 10, ++ ZCL_CRED_TYPE_UNSPECIFIED_BIOMETRIC = 11, ++} CredType; ++ + // Enum for CredentialRuleEnum + typedef enum { + ZCL_CREDENTIAL_RULE_ENUM_SINGLE = 0, +@@ -1349,6 +1371,33 @@ typedef enum { + ZCL_UNIFY_THERMOSTAT_THERMOSTAT_MODE_MANUFACTURER_SPECIFIC = 31, + } UnifyThermostatThermostatMode; + ++// Enum for UserModifierType ++typedef enum { ++ ZCL_USER_MODIFIER_TYPE_DNE = 0, ++ ZCL_USER_MODIFIER_TYPE_UNKNOWN = 1, ++ ZCL_USER_MODIFIER_TYPE_Z_WAVE = 2, ++ ZCL_USER_MODIFIER_TYPE_LOCALLY = 3, ++ ZCL_USER_MODIFIER_TYPE_MOBILE_APP_OR_OTHER_IO_T = 4, ++} UserModifierType; ++ ++// Enum for UserNameEncodingType ++typedef enum { ++ ZCL_USER_NAME_ENCODING_TYPE_ASCII = 0, ++ ZCL_USER_NAME_ENCODING_TYPE_OEM_EXTENDED_ASCII = 1, ++ ZCL_USER_NAME_ENCODING_TYPE_UTF_16 = 2, ++} UserNameEncodingType; ++ ++// Enum for UserTypeEnum ++typedef enum { ++ ZCL_USER_TYPE_ENUM_GENERAL_USER = 0, ++ ZCL_USER_TYPE_ENUM_PROGRAMMING_USER = 3, ++ ZCL_USER_TYPE_ENUM_NON_ACCESS_USER = 4, ++ ZCL_USER_TYPE_ENUM_DURESS_USER = 5, ++ ZCL_USER_TYPE_ENUM_DISPOSABLE_USER = 6, ++ ZCL_USER_TYPE_ENUM_EXPIRING_USER = 7, ++ ZCL_USER_TYPE_ENUM_REMOTE_ONLY_USER = 9, ++} UserTypeEnum; ++ + // Enum for WindowCoveringWindowCoveringType + typedef enum { + ZCL_WINDOW_COVERING_WINDOW_COVERING_TYPE_ROLLERSHADE = 0, +@@ -2129,6 +2178,48 @@ typedef enum { + #define UNIFY_THERMOSTAT_SUPPORTED_THERMOSTAT_MODE_FULL_POWER_OFFSET (14) + #define UNIFY_THERMOSTAT_SUPPORTED_THERMOSTAT_MODE_MANUFACTURER_SPECIFIC (32768) + #define UNIFY_THERMOSTAT_SUPPORTED_THERMOSTAT_MODE_MANUFACTURER_SPECIFIC_OFFSET (15) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_SINGLE (2) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_SINGLE_OFFSET (1) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_DUAL (4) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_DUAL_OFFSET (2) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_TRIPLE (8) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_TRIPLE_OFFSET (3) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_PIN_CODE (1) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_PIN_CODE_OFFSET (0) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_PASSWORD (2) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_PASSWORD_OFFSET (1) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_RFID_CODE (4) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_RFID_CODE_OFFSET (2) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_BLE (8) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_BLE_OFFSET (3) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_NFC (16) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_NFC_OFFSET (4) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_UWB (32) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_UWB_OFFSET (5) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_EYE_BIOMETRIC (64) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_EYE_BIOMETRIC_OFFSET (6) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_FACE_BIOMETRIC (128) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_FACE_BIOMETRIC_OFFSET (7) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_FINGER_BIOMETRIC (256) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_FINGER_BIOMETRIC_OFFSET (8) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_HAND_BIOMETRIC (512) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_HAND_BIOMETRIC_OFFSET (9) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_UNSPECIFIED_BIOMETRIC (1024) ++#define USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_UNSPECIFIED_BIOMETRIC_OFFSET (10) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_GENERAL_USER (1) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_GENERAL_USER_OFFSET (0) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_PROGRAMMING_USER (8) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_PROGRAMMING_USER_OFFSET (3) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_NON_ACCESS_USER (16) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_NON_ACCESS_USER_OFFSET (4) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_DURESS_USER (32) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_DURESS_USER_OFFSET (5) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_DISPOSABLE_USER (64) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_DISPOSABLE_USER_OFFSET (6) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_EXPIRING_USER (128) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_EXPIRING_USER_OFFSET (7) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_REMOTE_ONLY_USER (512) ++#define USER_CREDENTIAL_SUPPORTED_USER_TYPES_REMOTE_ONLY_USER_OFFSET (9) + #define WINDOW_COVERING_CONFIG_OR_STATUS_OPERATIONAL (1) + #define WINDOW_COVERING_CONFIG_OR_STATUS_OPERATIONAL_OFFSET (0) + #define WINDOW_COVERING_CONFIG_OR_STATUS_ONLINE (2) +diff --git a/components/uic_dotdot/zap-generated/readme_ucl_mqtt_reference.md b/components/uic_dotdot/zap-generated/readme_ucl_mqtt_reference.md +index 5316b884c2..18ad4f947e 100644 +--- a/components/uic_dotdot/zap-generated/readme_ucl_mqtt_reference.md ++++ b/components/uic_dotdot/zap-generated/readme_ucl_mqtt_reference.md +@@ -51886,6 +51886,1571 @@ mosquitto_pub -t 'ucl/by-unid///ConfigurationParameters/Commands/Force +


+ + ++ ++ ++ ++ ++ ++\page user_credential UserCredential Cluster ++The following commands and attributes are accepted as JSON payloads for the ++UserCredential cluster. ++ ++

++ ++ ++ ++ ++\section user_credential_attrs UserCredential Attributes ++The following attribute topics are used to retrieve the UserCredential cluster state. ++ ++
++ ++\subsection user_credential_attr_supported_user_unique_identifiers UserCredential/SupportedUserUniqueIdentifiers Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportedUserUniqueIdentifiers/Reported ++[PREFIX]/UserCredential/Attributes/SupportedUserUniqueIdentifiers/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportedUserUniqueIdentifiers Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportedUserUniqueIdentifiers attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportedUserUniqueIdentifiers/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedUserUniqueIdentifiers/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedUserUniqueIdentifiers/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_supported_credential_rules UserCredential/SupportedCredentialRules Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportedCredentialRules/Reported ++[PREFIX]/UserCredential/Attributes/SupportedCredentialRules/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportedCredentialRules Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "UserCredentialSupportedCredentialRules" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportedCredentialRules attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportedCredentialRules/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedCredentialRules/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedCredentialRules/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_supported_credential_types UserCredential/SupportedCredentialTypes Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportedCredentialTypes/Reported ++[PREFIX]/UserCredential/Attributes/SupportedCredentialTypes/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportedCredentialTypes Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "UserCredentialSupportedCredentialTypes" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportedCredentialTypes attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportedCredentialTypes/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedCredentialTypes/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedCredentialTypes/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_supported_user_types UserCredential/SupportedUserTypes Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportedUserTypes/Reported ++[PREFIX]/UserCredential/Attributes/SupportedUserTypes/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportedUserTypes Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "UserCredentialSupportedUserTypes" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportedUserTypes attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportedUserTypes/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedUserTypes/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportedUserTypes/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_support_credential_checksum UserCredential/SupportCredentialChecksum Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportCredentialChecksum/Reported ++[PREFIX]/UserCredential/Attributes/SupportCredentialChecksum/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportCredentialChecksum Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "boolean" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportCredentialChecksum attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportCredentialChecksum/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportCredentialChecksum/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportCredentialChecksum/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_support_admin_pin_code UserCredential/SupportAdminPinCode Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportAdminPinCode/Reported ++[PREFIX]/UserCredential/Attributes/SupportAdminPinCode/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportAdminPinCode Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "boolean" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportAdminPinCode attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportAdminPinCode/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportAdminPinCode/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportAdminPinCode/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_support_admin_pin_code_deactivation UserCredential/SupportAdminPinCodeDeactivation Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/SupportAdminPinCodeDeactivation/Reported ++[PREFIX]/UserCredential/Attributes/SupportAdminPinCodeDeactivation/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SupportAdminPinCodeDeactivation Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "boolean" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for SupportAdminPinCodeDeactivation attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/SupportAdminPinCodeDeactivation/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/SupportAdminPinCodeDeactivation/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/SupportAdminPinCodeDeactivation/Reported { "value": } ++ ++``` ++ ++

++ ++\subsection user_credential_attr_admin_pin_code UserCredential/AdminPinCode Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/AdminPinCode/Reported ++[PREFIX]/UserCredential/Attributes/AdminPinCode/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster AdminPinCode Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "string" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for AdminPinCode attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid/+/+/UserCredential/Attributes/AdminPinCode/+' ++ ++# Example output ++ ++ucl/by-unid//ep0/UserCredential/Attributes/AdminPinCode/Desired { "value": } ++ucl/by-unid//ep0/UserCredential/Attributes/AdminPinCode/Reported { "value": } ++ ++``` ++ ++

++ ++ ++\subsection user_credential_attr_cluster_revision UserCredential/ClusterRevision Attribute ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Attributes/ClusterRevision/Reported ++[PREFIX]/UserCredential/Attributes/ClusterRevision/Desired ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster ClusterRevision Attribute Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see desired/reported value for ClusterRevision attribute under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/Attributes/ClusterRevision/+' ++# Example output ++ucl/by-unid///UserCredential/Attributes/ClusterRevision/Desired { "value": } ++ucl/by-unid///UserCredential/Attributes/ClusterRevision/Reported { "value": } ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section user_credential_recv_cmd_support UserCredential Command Support ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/SupportedCommands ++[PREFIX]/UserCredential/SupportedGeneratedCommands ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Command Support Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "array", ++ "items" : { ++ "type": "string", ++ "enum": [ ++ "AddUser", ++ "ModifyUser", ++ "DeleteUser", ++ "AddCredential", ++ "ModifyCredential", ++ "DeleteCredential", ++ "DeleteAllUsers", ++ "DeleteAllCredentials", ++ "DeleteAllCredentialsByType", ++ "DeleteAllCredentialsForUser", ++ "DeleteAllCredentialsForUserByType", ++ "CredentialLearnStartAdd", ++ "CredentialLearnStartModify", ++ "CredentialLearnStop", ++ "CredentialAssociation", ++ "GetUserChecksum", ++ "GetCredentialChecksum", ++ "GetAllUsersChecksum", ++ "SetAdminPINCode", ++ "DeactivateAdminPINCode", ++ "WriteAttributes", ++ "ForceReadAttributes" ++ ] ++ } ++ } ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To see supported commands for UserCredential cluster under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/SupportedCommands' ++# Example output ++ucl/by-unid///UserCredential/SupportedCommands { "value": ["AddUser","ModifyUser","DeleteUser","AddCredential","ModifyCredential","DeleteCredential","DeleteAllUsers","DeleteAllCredentials","DeleteAllCredentialsByType","DeleteAllCredentialsForUser","DeleteAllCredentialsForUserByType","CredentialLearnStartAdd","CredentialLearnStartModify","CredentialLearnStop","CredentialAssociation","GetUserChecksum","GetCredentialChecksum","GetAllUsersChecksum","SetAdminPINCode","DeactivateAdminPINCode","WriteAttributes", "ForceReadAttributes"] } ++``` ++ ++To see supported generated commands for UserCredential cluster under the by-unid topic space: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/SupportedGeneratedCommands' ++# Example output ++ucl/by-unid///UserCredential/SupportedGeneratedCommands { "value": [] } ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section user_credential_cmds UserCredential Commands ++ ++

++ ++\subsection user_credential_add_user_cmd UserCredential/AddUser Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/AddUser ++[PREFIX]/UserCredential/GeneratedCommands/AddUser ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster AddUser Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "UserType": { ++ "type": "UserTypeEnum" ++ }, ++ "UserActiveState": { ++ "type": "boolean" ++ }, ++ "CredentialRule": { ++ "type": "CredRule" ++ }, ++ "UserName": { ++ "type": "string" ++ }, ++ "ExpiringTimeoutMinutes": { ++ "type": "integer" ++ }, ++ "UserNameEncoding": { ++ "type": "UserNameEncodingType" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "UserType", ++ "UserActiveState", ++ "CredentialRule", ++ "UserName", ++ "ExpiringTimeoutMinutes", ++ "UserNameEncoding" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/AddUser command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/AddUser' -m '{ "UserUniqueID": ,"UserType": ,"UserActiveState": ,"CredentialRule": ,"UserName": ,"ExpiringTimeoutMinutes": ,"UserNameEncoding": }' ++``` ++ ++To receive a UserCredential/AddUser generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/AddUser' ++``` ++ ++

++ ++\subsection user_credential_modify_user_cmd UserCredential/ModifyUser Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/ModifyUser ++[PREFIX]/UserCredential/GeneratedCommands/ModifyUser ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster ModifyUser Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "UserType": { ++ "type": "UserTypeEnum" ++ }, ++ "UserActiveState": { ++ "type": "boolean" ++ }, ++ "CredentialRule": { ++ "type": "CredRule" ++ }, ++ "UserName": { ++ "type": "string" ++ }, ++ "ExpiringTimeoutMinutes": { ++ "type": "integer" ++ }, ++ "UserNameEncoding": { ++ "type": "UserNameEncodingType" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "UserType", ++ "UserActiveState", ++ "CredentialRule", ++ "UserName", ++ "ExpiringTimeoutMinutes", ++ "UserNameEncoding" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/ModifyUser command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/ModifyUser' -m '{ "UserUniqueID": ,"UserType": ,"UserActiveState": ,"CredentialRule": ,"UserName": ,"ExpiringTimeoutMinutes": ,"UserNameEncoding": }' ++``` ++ ++To receive a UserCredential/ModifyUser generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/ModifyUser' ++``` ++ ++

++ ++\subsection user_credential_delete_user_cmd UserCredential/DeleteUser Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteUser ++[PREFIX]/UserCredential/GeneratedCommands/DeleteUser ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteUser Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteUser command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteUser' -m '{ "UserUniqueID": }' ++``` ++ ++To receive a UserCredential/DeleteUser generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteUser' ++``` ++ ++

++ ++\subsection user_credential_add_credential_cmd UserCredential/AddCredential Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/AddCredential ++[PREFIX]/UserCredential/GeneratedCommands/AddCredential ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster AddCredential Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "CredentialSlot": { ++ "type": "integer" ++ }, ++ "CredentialData": { ++ "type": "string" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType", ++ "CredentialSlot", ++ "CredentialData" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/AddCredential command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/AddCredential' -m '{ "UserUniqueID": ,"CredentialType": ,"CredentialSlot": ,"CredentialData": }' ++``` ++ ++To receive a UserCredential/AddCredential generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/AddCredential' ++``` ++ ++

++ ++\subsection user_credential_modify_credential_cmd UserCredential/ModifyCredential Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/ModifyCredential ++[PREFIX]/UserCredential/GeneratedCommands/ModifyCredential ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster ModifyCredential Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "CredentialSlot": { ++ "type": "integer" ++ }, ++ "CredentialData": { ++ "type": "string" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType", ++ "CredentialSlot", ++ "CredentialData" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/ModifyCredential command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/ModifyCredential' -m '{ "UserUniqueID": ,"CredentialType": ,"CredentialSlot": ,"CredentialData": }' ++``` ++ ++To receive a UserCredential/ModifyCredential generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/ModifyCredential' ++``` ++ ++

++ ++\subsection user_credential_delete_credential_cmd UserCredential/DeleteCredential Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteCredential ++[PREFIX]/UserCredential/GeneratedCommands/DeleteCredential ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteCredential Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "CredentialSlot": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType", ++ "CredentialSlot" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteCredential command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteCredential' -m '{ "UserUniqueID": ,"CredentialType": ,"CredentialSlot": }' ++``` ++ ++To receive a UserCredential/DeleteCredential generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteCredential' ++``` ++ ++

++ ++\subsection user_credential_delete_all_users_cmd UserCredential/DeleteAllUsers Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteAllUsers ++[PREFIX]/UserCredential/GeneratedCommands/DeleteAllUsers ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteAllUsers Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteAllUsers command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteAllUsers' -m '{ }' ++``` ++ ++To receive a UserCredential/DeleteAllUsers generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteAllUsers' ++``` ++ ++

++ ++\subsection user_credential_delete_all_credentials_cmd UserCredential/DeleteAllCredentials Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteAllCredentials ++[PREFIX]/UserCredential/GeneratedCommands/DeleteAllCredentials ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteAllCredentials Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteAllCredentials command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteAllCredentials' -m '{ }' ++``` ++ ++To receive a UserCredential/DeleteAllCredentials generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteAllCredentials' ++``` ++ ++

++ ++\subsection user_credential_delete_all_credentials_by_type_cmd UserCredential/DeleteAllCredentialsByType Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteAllCredentialsByType ++[PREFIX]/UserCredential/GeneratedCommands/DeleteAllCredentialsByType ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteAllCredentialsByType Command Properties", ++ "type": "object", ++ "properties": { ++ "CredentialType": { ++ "type": "CredType" ++ } ++ }, ++ "required": [ ++ "CredentialType" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteAllCredentialsByType command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteAllCredentialsByType' -m '{ "CredentialType": }' ++``` ++ ++To receive a UserCredential/DeleteAllCredentialsByType generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteAllCredentialsByType' ++``` ++ ++

++ ++\subsection user_credential_delete_all_credentials_for_user_cmd UserCredential/DeleteAllCredentialsForUser Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteAllCredentialsForUser ++[PREFIX]/UserCredential/GeneratedCommands/DeleteAllCredentialsForUser ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteAllCredentialsForUser Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteAllCredentialsForUser command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteAllCredentialsForUser' -m '{ "UserUniqueID": }' ++``` ++ ++To receive a UserCredential/DeleteAllCredentialsForUser generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteAllCredentialsForUser' ++``` ++ ++

++ ++\subsection user_credential_delete_all_credentials_for_user_by_type_cmd UserCredential/DeleteAllCredentialsForUserByType Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeleteAllCredentialsForUserByType ++[PREFIX]/UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeleteAllCredentialsForUserByType Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeleteAllCredentialsForUserByType command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeleteAllCredentialsForUserByType' -m '{ "UserUniqueID": ,"CredentialType": }' ++``` ++ ++To receive a UserCredential/DeleteAllCredentialsForUserByType generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeleteAllCredentialsForUserByType' ++``` ++ ++

++ ++\subsection user_credential_credential_learn_start_add_cmd UserCredential/CredentialLearnStartAdd Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/CredentialLearnStartAdd ++[PREFIX]/UserCredential/GeneratedCommands/CredentialLearnStartAdd ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster CredentialLearnStartAdd Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "CredentialSlot": { ++ "type": "integer" ++ }, ++ "CredentialLearnTimeout": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType", ++ "CredentialSlot", ++ "CredentialLearnTimeout" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/CredentialLearnStartAdd command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/CredentialLearnStartAdd' -m '{ "UserUniqueID": ,"CredentialType": ,"CredentialSlot": ,"CredentialLearnTimeout": }' ++``` ++ ++To receive a UserCredential/CredentialLearnStartAdd generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/CredentialLearnStartAdd' ++``` ++ ++

++ ++\subsection user_credential_credential_learn_start_modify_cmd UserCredential/CredentialLearnStartModify Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/CredentialLearnStartModify ++[PREFIX]/UserCredential/GeneratedCommands/CredentialLearnStartModify ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster CredentialLearnStartModify Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ }, ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "CredentialSlot": { ++ "type": "integer" ++ }, ++ "CredentialLearnTimeout": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID", ++ "CredentialType", ++ "CredentialSlot", ++ "CredentialLearnTimeout" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/CredentialLearnStartModify command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/CredentialLearnStartModify' -m '{ "UserUniqueID": ,"CredentialType": ,"CredentialSlot": ,"CredentialLearnTimeout": }' ++``` ++ ++To receive a UserCredential/CredentialLearnStartModify generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/CredentialLearnStartModify' ++``` ++ ++

++ ++\subsection user_credential_credential_learn_stop_cmd UserCredential/CredentialLearnStop Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/CredentialLearnStop ++[PREFIX]/UserCredential/GeneratedCommands/CredentialLearnStop ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster CredentialLearnStop Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/CredentialLearnStop command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/CredentialLearnStop' -m '{ }' ++``` ++ ++To receive a UserCredential/CredentialLearnStop generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/CredentialLearnStop' ++``` ++ ++

++ ++\subsection user_credential_credential_association_cmd UserCredential/CredentialAssociation Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/CredentialAssociation ++[PREFIX]/UserCredential/GeneratedCommands/CredentialAssociation ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster CredentialAssociation Command Properties", ++ "type": "object", ++ "properties": { ++ "CredentialType": { ++ "type": "CredType" ++ }, ++ "SourceUserUniqueID": { ++ "type": "integer" ++ }, ++ "SourceCredentialSlot": { ++ "type": "integer" ++ }, ++ "DestinationUserUniqueID": { ++ "type": "integer" ++ }, ++ "DestinationCredentialSlot": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "CredentialType", ++ "SourceUserUniqueID", ++ "SourceCredentialSlot", ++ "DestinationUserUniqueID", ++ "DestinationCredentialSlot" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/CredentialAssociation command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/CredentialAssociation' -m '{ "CredentialType": ,"SourceUserUniqueID": ,"SourceCredentialSlot": ,"DestinationUserUniqueID": ,"DestinationCredentialSlot": }' ++``` ++ ++To receive a UserCredential/CredentialAssociation generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/CredentialAssociation' ++``` ++ ++

++ ++\subsection user_credential_get_user_checksum_cmd UserCredential/GetUserChecksum Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/GetUserChecksum ++[PREFIX]/UserCredential/GeneratedCommands/GetUserChecksum ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster GetUserChecksum Command Properties", ++ "type": "object", ++ "properties": { ++ "UserUniqueID": { ++ "type": "integer" ++ } ++ }, ++ "required": [ ++ "UserUniqueID" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/GetUserChecksum command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/GetUserChecksum' -m '{ "UserUniqueID": }' ++``` ++ ++To receive a UserCredential/GetUserChecksum generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/GetUserChecksum' ++``` ++ ++

++ ++\subsection user_credential_get_credential_checksum_cmd UserCredential/GetCredentialChecksum Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/GetCredentialChecksum ++[PREFIX]/UserCredential/GeneratedCommands/GetCredentialChecksum ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster GetCredentialChecksum Command Properties", ++ "type": "object", ++ "properties": { ++ "CredentialType": { ++ "type": "CredType" ++ } ++ }, ++ "required": [ ++ "CredentialType" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/GetCredentialChecksum command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/GetCredentialChecksum' -m '{ "CredentialType": }' ++``` ++ ++To receive a UserCredential/GetCredentialChecksum generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/GetCredentialChecksum' ++``` ++ ++

++ ++\subsection user_credential_get_all_users_checksum_cmd UserCredential/GetAllUsersChecksum Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/GetAllUsersChecksum ++[PREFIX]/UserCredential/GeneratedCommands/GetAllUsersChecksum ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster GetAllUsersChecksum Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/GetAllUsersChecksum command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/GetAllUsersChecksum' -m '{ }' ++``` ++ ++To receive a UserCredential/GetAllUsersChecksum generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/GetAllUsersChecksum' ++``` ++ ++

++ ++\subsection user_credential_set_admin_pin_code_cmd UserCredential/SetAdminPINCode Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/SetAdminPINCode ++[PREFIX]/UserCredential/GeneratedCommands/SetAdminPINCode ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster SetAdminPINCode Command Properties", ++ "type": "object", ++ "properties": { ++ "PINCode": { ++ "type": "string" ++ } ++ }, ++ "required": [ ++ "PINCode" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/SetAdminPINCode command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/SetAdminPINCode' -m '{ "PINCode": }' ++``` ++ ++To receive a UserCredential/SetAdminPINCode generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/SetAdminPINCode' ++``` ++ ++

++ ++\subsection user_credential_deactivate_admin_pin_code_cmd UserCredential/DeactivateAdminPINCode Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/DeactivateAdminPINCode ++[PREFIX]/UserCredential/GeneratedCommands/DeactivateAdminPINCode ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster DeactivateAdminPINCode Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To send a UserCredential/DeactivateAdminPINCode command under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/DeactivateAdminPINCode' -m '{ }' ++``` ++ ++To receive a UserCredential/DeactivateAdminPINCode generated command from a UNID/endpoint: ++ ++```console ++mosquitto_sub -t 'ucl/by-unid///UserCredential/GeneratedCommands/DeactivateAdminPINCode' ++``` ++ ++

++ ++\subsection user_credential_write_attr_cmd UserCredential/WriteAttributes Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/WriteAttributes ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster WriteAttributes Command Properties", ++ "type": "object", ++ "properties": { ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To update all UserCredential attributes under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/WriteAttributes' -m '{ }' ++``` ++ ++> NOTE: Specify only the list of attributes to write in this command. ++> Unspecified attributes will not be updated. ++ ++

++ ++\subsection user_credential_force_read_attr_cmd UserCredential/ForceReadAttributes Command ++ ++**MQTT Topic Pattern:** ++ ++``` ++[PREFIX]/UserCredential/Commands/ForceReadAttributes ++``` ++ ++**MQTT Payload JSON Schema:** ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredential Cluster ForceReadAttributes Command Properties", ++ "type": "object", ++ "properties": { ++ "value": { ++ "type": "array" ++ "items": { ++ "type": "string", ++ "enum": [ ++ "SupportedUserUniqueIdentifiers", ++ "SupportedCredentialRules", ++ "SupportedCredentialTypes", ++ "SupportedUserTypes", ++ "SupportCredentialChecksum", ++ "SupportAdminPinCode", ++ "SupportAdminPinCodeDeactivation", ++ "AdminPinCode" ++ ] ++ } ++ } ++ }, ++ "required": [ ++ "value" ++ ] ++} ++``` ++ ++**Example Mosquitto CLI Tool Usage** ++ ++To force read all UserCredential attributes under the by-unid topic space (by sending an empty array): ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/ForceReadAttributes' -m '{ "value": [] }' ++``` ++ ++To force read one of the UserCredential attributes under the by-unid topic space: ++ ++```console ++mosquitto_pub -t 'ucl/by-unid///UserCredential/Commands/ForceReadAttributes' -m '{ "value": ["SupportedUserUniqueIdentifiers"] }' ++``` ++ ++ ++ ++ ++ ++


++ ++ + + + +@@ -54602,33 +56167,6 @@ mosquitto_pub -t 'ucl/by-unid///UnifyHumidityControl/Commands/ForceRea + +

+ +- +- +- +-\section struct_credential_struct CredentialStruct Struct +- +-```json +-{ +- "$schema": "http://json-schema.org/draft-07/schema#", +- "title": "CredentialStruct Struct Properties", +- "type": "object", +- "properties": { +- "CredentialType": { +- "type": "CredentialTypeEnum" +- } +- "CredentialIndex": { +- "type": "integer" +- } +- } +-} +-``` +- +- +- +- +- +-

+- + + + +@@ -55812,6 +57350,62 @@ mosquitto_pub -t 'ucl/by-unid///UnifyHumidityControl/Commands/ForceRea + +

+ ++ ++ ++ ++\section enum_cred_rule CredRule Enum ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "CredRule Enum Properties", ++ "type": "string", ++ "enum": [ ++ "Single", ++ "Dual", ++ "Triple" ++ ] ++} ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section enum_cred_type CredType Enum ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "CredType Enum Properties", ++ "type": "string", ++ "enum": [ ++ "PINCode", ++ "Password", ++ "RFIDCode", ++ "BLE", ++ "NFC", ++ "UWB", ++ "EyeBiometric", ++ "FaceBiometric", ++ "FingerBiometric", ++ "HandBiometric", ++ "UnspecifiedBiometric" ++ ] ++} ++``` ++ ++ ++ ++ ++ ++

++ + + + +@@ -58217,6 +59811,84 @@ mosquitto_pub -t 'ucl/by-unid///UnifyHumidityControl/Commands/ForceRea + +

+ ++ ++ ++ ++\section enum_user_modifier_type UserModifierType Enum ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserModifierType Enum Properties", ++ "type": "string", ++ "enum": [ ++ "DNE", ++ "Unknown", ++ "Z-Wave", ++ "Locally", ++ "MobileAppOrOtherIoT" ++ ] ++} ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section enum_user_name_encoding_type UserNameEncodingType Enum ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserNameEncodingType Enum Properties", ++ "type": "string", ++ "enum": [ ++ "ASCII", ++ "OEMExtendedASCII", ++ "UTF-16" ++ ] ++} ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section enum_user_type_enum UserTypeEnum Enum ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserTypeEnum Enum Properties", ++ "type": "string", ++ "enum": [ ++ "GeneralUser", ++ "ProgrammingUser", ++ "NonAccessUser", ++ "DuressUser", ++ "DisposableUser", ++ "ExpiringUser", ++ "RemoteOnlyUser" ++ ] ++} ++``` ++ ++ ++ ++ ++ ++

++ + + + +@@ -60868,6 +62540,132 @@ mosquitto_pub -t 'ucl/by-unid///UnifyHumidityControl/Commands/ForceRea + +

+ ++ ++ ++ ++\section enum_user_credential_supported_credential_rules UserCredentialSupportedCredentialRules Bitmap ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredentialSupportedCredentialRules Enum Properties", ++ "type": "object", ++ "properties": { ++ "Single": { ++ "type": "boolean" ++ }, ++ "Dual": { ++ "type": "boolean" ++ }, ++ "Triple": { ++ "type": "boolean" ++ } ++ } ++} ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section enum_user_credential_supported_credential_types UserCredentialSupportedCredentialTypes Bitmap ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredentialSupportedCredentialTypes Enum Properties", ++ "type": "object", ++ "properties": { ++ "PINCode": { ++ "type": "boolean" ++ }, ++ "Password": { ++ "type": "boolean" ++ }, ++ "RFIDCode": { ++ "type": "boolean" ++ }, ++ "BLE": { ++ "type": "boolean" ++ }, ++ "NFC": { ++ "type": "boolean" ++ }, ++ "UWB": { ++ "type": "boolean" ++ }, ++ "EyeBiometric": { ++ "type": "boolean" ++ }, ++ "FaceBiometric": { ++ "type": "boolean" ++ }, ++ "FingerBiometric": { ++ "type": "boolean" ++ }, ++ "HandBiometric": { ++ "type": "boolean" ++ }, ++ "UnspecifiedBiometric": { ++ "type": "boolean" ++ } ++ } ++} ++``` ++ ++ ++ ++ ++ ++

++ ++ ++ ++ ++\section enum_user_credential_supported_user_types UserCredentialSupportedUserTypes Bitmap ++ ++```json ++{ ++ "$schema": "http://json-schema.org/draft-07/schema#", ++ "title": "UserCredentialSupportedUserTypes Enum Properties", ++ "type": "object", ++ "properties": { ++ "GeneralUser": { ++ "type": "boolean" ++ }, ++ "ProgrammingUser": { ++ "type": "boolean" ++ }, ++ "NonAccessUser": { ++ "type": "boolean" ++ }, ++ "DuressUser": { ++ "type": "boolean" ++ }, ++ "DisposableUser": { ++ "type": "boolean" ++ }, ++ "ExpiringUser": { ++ "type": "boolean" ++ }, ++ "RemoteOnlyUser": { ++ "type": "boolean" ++ } ++ } ++} ++``` ++ ++ ++ ++ ++ ++

++ + + + +diff --git a/components/uic_dotdot/zap-generated/src/dotdot_attribute_id_definitions.c b/components/uic_dotdot/zap-generated/src/dotdot_attribute_id_definitions.c +index badc743381..372b67422a 100644 +--- a/components/uic_dotdot/zap-generated/src/dotdot_attribute_id_definitions.c ++++ b/components/uic_dotdot/zap-generated/src/dotdot_attribute_id_definitions.c +@@ -1947,6 +1947,31 @@ const char *uic_dotdot_get_attribute_name(dotdot_cluster_id_t cluster_id, + return "Unknown"; + } + // clang-format off ++ case DOTDOT_USER_CREDENTIAL_CLUSTER_ID: ++ // clang-format on ++ switch (attribute_id) { ++ // clang-format off ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ATTRIBUTE_ID: ++ return "SupportedUserUniqueIdentifiers"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ATTRIBUTE_ID: ++ return "SupportedCredentialRules"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ATTRIBUTE_ID: ++ return "SupportedCredentialTypes"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_TYPES_ATTRIBUTE_ID: ++ return "SupportedUserTypes"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ATTRIBUTE_ID: ++ return "SupportCredentialChecksum"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ATTRIBUTE_ID: ++ return "SupportAdminPinCode"; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ATTRIBUTE_ID: ++ return "SupportAdminPinCodeDeactivation"; ++ case DOTDOT_USER_CREDENTIAL_ADMIN_PIN_CODE_ATTRIBUTE_ID: ++ return "AdminPinCode"; ++ // clang-format on ++ default: ++ return "Unknown"; ++ } ++ // clang-format off + case DOTDOT_AOX_LOCATOR_CLUSTER_ID: + // clang-format on + switch (attribute_id) { +@@ -4415,6 +4440,32 @@ dotdot_attribute_id_t + return DOTDOT_CONFIGURATION_PARAMETERS_CONFIGURATION_PARAMETERS_ATTRIBUTE_ID; + } + break; ++ case DOTDOT_USER_CREDENTIAL_CLUSTER_ID: ++ if (strcmp ("SupportedUserUniqueIdentifiers", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportedCredentialRules", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportedCredentialTypes", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportedUserTypes", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_TYPES_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportCredentialChecksum", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportAdminPinCode", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ATTRIBUTE_ID; ++ } ++ if (strcmp ("SupportAdminPinCodeDeactivation", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ATTRIBUTE_ID; ++ } ++ if (strcmp ("AdminPinCode", attribute_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_ADMIN_PIN_CODE_ATTRIBUTE_ID; ++ } ++ break; + case DOTDOT_AOX_LOCATOR_CLUSTER_ID: + if (strcmp ("ReportingMode", attribute_name) == 0) { + return DOTDOT_AOX_LOCATOR_REPORTING_MODE_ATTRIBUTE_ID; +@@ -6506,6 +6557,31 @@ dotdot_attribute_json_type_t + return JSON_TYPE_UNKNOWN; + } + // clang-format off ++ case DOTDOT_USER_CREDENTIAL_CLUSTER_ID: ++ // clang-format on ++ switch (attribute_id) { ++ // clang-format off ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS_ATTRIBUTE_ID: ++ return JSON_TYPE_NUMBER; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES_ATTRIBUTE_ID: ++ return JSON_TYPE_NUMBER; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES_ATTRIBUTE_ID: ++ return JSON_TYPE_NUMBER; ++ case DOTDOT_USER_CREDENTIAL_SUPPORTED_USER_TYPES_ATTRIBUTE_ID: ++ return JSON_TYPE_NUMBER; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM_ATTRIBUTE_ID: ++ return JSON_TYPE_BOOL; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_ATTRIBUTE_ID: ++ return JSON_TYPE_BOOL; ++ case DOTDOT_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION_ATTRIBUTE_ID: ++ return JSON_TYPE_BOOL; ++ case DOTDOT_USER_CREDENTIAL_ADMIN_PIN_CODE_ATTRIBUTE_ID: ++ return JSON_TYPE_STRING; ++ // clang-format on ++ default: ++ return JSON_TYPE_UNKNOWN; ++ } ++ // clang-format off + case DOTDOT_AOX_LOCATOR_CLUSTER_ID: + // clang-format on + switch (attribute_id) { +@@ -6982,6 +7058,9 @@ bool uic_dotdot_attribute_is_enum(dotdot_cluster_id_t cluster_id, + if (64775 == cluster_id) { + } + ++ if (64776 == cluster_id) { ++ } ++ + if (64786 == cluster_id) { + } + +diff --git a/components/uic_dotdot/zap-generated/src/dotdot_cluster_id_definitions.c b/components/uic_dotdot/zap-generated/src/dotdot_cluster_id_definitions.c +index 8699e827dc..a5c8e4d09b 100644 +--- a/components/uic_dotdot/zap-generated/src/dotdot_cluster_id_definitions.c ++++ b/components/uic_dotdot/zap-generated/src/dotdot_cluster_id_definitions.c +@@ -120,6 +120,8 @@ const char* uic_dotdot_get_cluster_name(dotdot_cluster_id_t cluster_id) { + return "NameAndLocation"; + case DOTDOT_CONFIGURATION_PARAMETERS_CLUSTER_ID: + return "ConfigurationParameters"; ++ case DOTDOT_USER_CREDENTIAL_CLUSTER_ID: ++ return "UserCredential"; + case DOTDOT_AOX_LOCATOR_CLUSTER_ID: + return "AoXLocator"; + case DOTDOT_AOX_POSITION_ESTIMATION_CLUSTER_ID: +@@ -293,6 +295,9 @@ dotdot_cluster_id_t uic_dotdot_get_cluster_id(const char* cluster_name) { + if (strcmp ("ConfigurationParameters", cluster_name) == 0) { + return DOTDOT_CONFIGURATION_PARAMETERS_CLUSTER_ID; + } ++ if (strcmp ("UserCredential", cluster_name) == 0) { ++ return DOTDOT_USER_CREDENTIAL_CLUSTER_ID; ++ } + if (strcmp ("AoXLocator", cluster_name) == 0) { + return DOTDOT_AOX_LOCATOR_CLUSTER_ID; + } +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h +index 47a3d4a00c..7106f0f0fc 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt.h +@@ -111,17 +111,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_reset_to_factory_defaults_callback_t + ); + + typedef struct { +- int8_t zcl_version; +- int8_t application_version; +- int8_t stack_version; +- int8_t hw_version; ++ uint8_t zcl_version; ++ uint8_t application_version; ++ uint8_t stack_version; ++ uint8_t hw_version; + const char* manufacturer_name; + const char* model_identifier; + const char* date_code; + uint8_t power_source; + uint8_t generic_device_class; + uint8_t generic_device_type; +- uint8_t product_code; ++ const char* product_code; + const char* producturl; + const char* manufacturer_version_details; + const char* serial_number; +@@ -277,7 +277,7 @@ void uic_mqtt_dotdot_clear_basic_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_basic_zcl_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -307,7 +307,7 @@ sl_status_t uic_mqtt_dotdot_basic_zcl_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_application_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -337,7 +337,7 @@ sl_status_t uic_mqtt_dotdot_basic_application_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_stack_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -367,7 +367,7 @@ sl_status_t uic_mqtt_dotdot_basic_stack_version_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_hw_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -577,7 +577,7 @@ sl_status_t uic_mqtt_dotdot_basic_generic_device_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_basic_product_code_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -942,62 +942,62 @@ void uic_mqtt_dotdot_basic_publish_empty_supported_commands( + // Callback types used by the power_configuration cluster + + typedef struct { +- int16_t mains_voltage; +- int8_t mains_frequency; ++ uint16_t mains_voltage; ++ uint8_t mains_frequency; + uint8_t mains_alarm_mask; +- int16_t mains_voltage_min_threshold; +- int16_t mains_voltage_max_threshold; +- int16_t mains_voltage_dwell_trip_point; +- int8_t battery_voltage; +- int8_t battery_percentage_remaining; ++ uint16_t mains_voltage_min_threshold; ++ uint16_t mains_voltage_max_threshold; ++ uint16_t mains_voltage_dwell_trip_point; ++ uint8_t battery_voltage; ++ uint8_t battery_percentage_remaining; + const char* battery_manufacturer; + uint8_t battery_size; +- int16_t batterya_hr_rating; +- int8_t battery_quantity; +- int8_t battery_rated_voltage; ++ uint16_t batterya_hr_rating; ++ uint8_t battery_quantity; ++ uint8_t battery_rated_voltage; + uint8_t battery_alarm_mask; +- int8_t battery_voltage_min_threshold; +- int8_t battery_voltage_threshold1; +- int8_t battery_voltage_threshold2; +- int8_t battery_voltage_threshold3; +- int8_t battery_percentage_min_threshold; +- int8_t battery_percentage_threshold1; +- int8_t battery_percentage_threshold2; +- int8_t battery_percentage_threshold3; ++ uint8_t battery_voltage_min_threshold; ++ uint8_t battery_voltage_threshold1; ++ uint8_t battery_voltage_threshold2; ++ uint8_t battery_voltage_threshold3; ++ uint8_t battery_percentage_min_threshold; ++ uint8_t battery_percentage_threshold1; ++ uint8_t battery_percentage_threshold2; ++ uint8_t battery_percentage_threshold3; + uint32_t battery_alarm_state; +- int8_t battery2_voltage; +- int8_t battery2_percentage_remaining; ++ uint8_t battery2_voltage; ++ uint8_t battery2_percentage_remaining; + const char* battery2_manufacturer; + uint8_t battery2_size; +- int16_t battery2a_hr_rating; +- int8_t battery2_quantity; +- int8_t battery2_rated_voltage; ++ uint16_t battery2a_hr_rating; ++ uint8_t battery2_quantity; ++ uint8_t battery2_rated_voltage; + uint8_t battery2_alarm_mask; +- int8_t battery2_voltage_min_threshold; +- int8_t battery2_voltage_threshold1; +- int8_t battery2_voltage_threshold2; +- int8_t battery2_voltage_threshold3; +- int8_t battery2_percentage_min_threshold; +- int8_t battery2_percentage_threshold1; +- int8_t battery2_percentage_threshold2; +- int8_t battery2_percentage_threshold3; ++ uint8_t battery2_voltage_min_threshold; ++ uint8_t battery2_voltage_threshold1; ++ uint8_t battery2_voltage_threshold2; ++ uint8_t battery2_voltage_threshold3; ++ uint8_t battery2_percentage_min_threshold; ++ uint8_t battery2_percentage_threshold1; ++ uint8_t battery2_percentage_threshold2; ++ uint8_t battery2_percentage_threshold3; + uint32_t battery2_alarm_state; +- int8_t battery3_voltage; +- int8_t battery3_percentage_remaining; ++ uint8_t battery3_voltage; ++ uint8_t battery3_percentage_remaining; + const char* battery3_manufacturer; + uint8_t battery3_size; +- int16_t battery3a_hr_rating; +- int8_t battery3_quantity; +- int8_t battery3_rated_voltage; ++ uint16_t battery3a_hr_rating; ++ uint8_t battery3_quantity; ++ uint8_t battery3_rated_voltage; + uint8_t battery3_alarm_mask; +- int8_t battery3_voltage_min_threshold; +- int8_t battery3_voltage_threshold1; +- int8_t battery3_voltage_threshold2; +- int8_t battery3_voltage_threshold3; +- int8_t battery3_percentage_min_threshold; +- int8_t battery3_percentage_threshold1; +- int8_t battery3_percentage_threshold2; +- int8_t battery3_percentage_threshold3; ++ uint8_t battery3_voltage_min_threshold; ++ uint8_t battery3_voltage_threshold1; ++ uint8_t battery3_voltage_threshold2; ++ uint8_t battery3_voltage_threshold3; ++ uint8_t battery3_percentage_min_threshold; ++ uint8_t battery3_percentage_threshold1; ++ uint8_t battery3_percentage_threshold2; ++ uint8_t battery3_percentage_threshold3; + uint32_t battery3_alarm_state; + } uic_mqtt_dotdot_power_configuration_state_t; + +@@ -1140,7 +1140,7 @@ void uic_mqtt_dotdot_clear_power_configuration_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1170,7 +1170,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1230,7 +1230,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1260,7 +1260,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1290,7 +1290,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1320,7 +1320,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1350,7 +1350,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1440,7 +1440,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1470,7 +1470,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1500,7 +1500,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1560,7 +1560,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1590,7 +1590,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1620,7 +1620,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1650,7 +1650,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1680,7 +1680,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_unret + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1710,7 +1710,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1740,7 +1740,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1770,7 +1770,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_un + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1830,7 +1830,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1860,7 +1860,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1950,7 +1950,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -1980,7 +1980,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2010,7 +2010,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2070,7 +2070,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2100,7 +2100,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2130,7 +2130,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2160,7 +2160,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2190,7 +2190,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2220,7 +2220,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshol + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2250,7 +2250,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2280,7 +2280,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2340,7 +2340,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2370,7 +2370,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2460,7 +2460,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_size_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2490,7 +2490,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2520,7 +2520,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2580,7 +2580,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_alarm_mask_unretain( + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2610,7 +2610,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2640,7 +2640,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2670,7 +2670,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2700,7 +2700,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_unre + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2730,7 +2730,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshol + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2760,7 +2760,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2790,7 +2790,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_u + */ + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -2888,12 +2888,12 @@ typedef struct { + int16_t current_temperature; + int16_t min_temp_experienced; + int16_t max_temp_experienced; +- int16_t over_temp_total_dwell; ++ uint16_t over_temp_total_dwell; + uint8_t device_temp_alarm_mask; + int16_t low_temp_threshold; + int16_t high_temp_threshold; +- int32_t low_temp_dwell_trip_point; +- int32_t high_temp_dwell_trip_point; ++ uint32_t low_temp_dwell_trip_point; ++ uint32_t high_temp_dwell_trip_point; + } uic_mqtt_dotdot_device_temperature_configuration_state_t; + + typedef struct { +@@ -3077,7 +3077,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_max_temp_experience + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3197,7 +3197,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_threshold + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3227,7 +3227,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip + */ + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3294,14 +3294,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t identify_time ++ uint16_t identify_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_query_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t timeout ++ uint16_t timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_identify_identify_query_callback_t)( +@@ -3320,7 +3320,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_trigger_effect_callback_t)( + ); + + typedef struct { +- int16_t identify_time; ++ uint16_t identify_time; + } uic_mqtt_dotdot_identify_state_t; + + typedef struct { +@@ -3347,14 +3347,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_force_read_attributes_callback_t) + * @brief Command fields for Identify/Identify + */ + typedef struct { +- int16_t identify_time; ++ uint16_t identify_time; + } uic_mqtt_dotdot_identify_command_identify_fields_t; + + /** + * @brief Command fields for Identify/IdentifyQueryResponse + */ + typedef struct { +- int16_t timeout; ++ uint16_t timeout; + } uic_mqtt_dotdot_identify_command_identify_query_response_fields_t; + + /** +@@ -3589,7 +3589,7 @@ void uic_mqtt_dotdot_clear_identify_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_identify_identify_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -3656,7 +3656,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -3667,14 +3667,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- int16_t group_id ++ uint16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t group_id ++ uint16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_response_callback_t)( +@@ -3683,7 +3683,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_view_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -3693,24 +3693,24 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_get_group_membership_callback_t)( + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t group_list_count, +- const int16_t *group_list ++ const uint16_t *group_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_get_group_membership_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t capacity, ++ uint8_t capacity, + + uint8_t group_list_count, +- const int16_t *group_list ++ const uint16_t *group_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t group_id ++ uint16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_response_callback_t)( +@@ -3719,7 +3719,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_group_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t status, + +- int16_t group_id ++ uint16_t group_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_groups_remove_all_groups_callback_t)( +@@ -3731,7 +3731,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_add_group_if_identifying_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -3765,7 +3765,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_groups_force_read_attributes_callback_t)( + * @brief Command fields for Groups/AddGroup + */ + typedef struct { +- int16_t group_id; ++ uint16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_add_group_fields_t; +@@ -3776,14 +3776,14 @@ typedef struct { + typedef struct { + uint8_t status; + +- int16_t group_id; ++ uint16_t group_id; + } uic_mqtt_dotdot_groups_command_add_group_response_fields_t; + + /** + * @brief Command fields for Groups/ViewGroup + */ + typedef struct { +- int16_t group_id; ++ uint16_t group_id; + } uic_mqtt_dotdot_groups_command_view_group_fields_t; + + /** +@@ -3792,7 +3792,7 @@ typedef struct { + typedef struct { + uint8_t status; + +- int16_t group_id; ++ uint16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_view_group_response_fields_t; +@@ -3802,24 +3802,24 @@ typedef struct { + */ + typedef struct { + uint8_t group_list_count; +- const int16_t *group_list; ++ const uint16_t *group_list; + } uic_mqtt_dotdot_groups_command_get_group_membership_fields_t; + + /** + * @brief Command fields for Groups/GetGroupMembershipResponse + */ + typedef struct { +- int8_t capacity; ++ uint8_t capacity; + + uint8_t group_list_count; +- const int16_t *group_list; ++ const uint16_t *group_list; + } uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t; + + /** + * @brief Command fields for Groups/RemoveGroup + */ + typedef struct { +- int16_t group_id; ++ uint16_t group_id; + } uic_mqtt_dotdot_groups_command_remove_group_fields_t; + + /** +@@ -3828,14 +3828,14 @@ typedef struct { + typedef struct { + uint8_t status; + +- int16_t group_id; ++ uint16_t group_id; + } uic_mqtt_dotdot_groups_command_remove_group_response_fields_t; + + /** + * @brief Command fields for Groups/AddGroupIfIdentifying + */ + typedef struct { +- int16_t group_id; ++ uint16_t group_id; + + const char* group_name; + } uic_mqtt_dotdot_groups_command_add_group_if_identifying_fields_t; +@@ -4370,18 +4370,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets, + +- int8_t transition_time100ms ++ uint8_t transition_time100ms + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_response_callback_t)( +@@ -4390,18 +4390,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_add_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_response_callback_t)( +@@ -4410,13 +4410,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_view_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4426,9 +4426,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_response_callback_t)( +@@ -4437,16 +4437,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid ++ uint16_t groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_t)( +@@ -4455,16 +4455,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid ++ uint16_t groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_response_callback_t)( +@@ -4473,27 +4473,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_store_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_recall_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time ++ uint16_t transition_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid ++ uint16_t groupid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_response_callback_t)( +@@ -4502,25 +4502,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_get_scene_membership_response_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- int8_t capacity, ++ uint8_t capacity, + +- uint8_t * groupid, ++ uint16_t groupid, + + uint8_t scene_list_count, +- const int8_t *scene_list ++ const uint8_t *scene_list + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_add_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4532,18 +4532,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callbac + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback_t)( +@@ -4552,13 +4552,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callba + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -4570,13 +4570,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t mode, + +- uint8_t * group_identifier_from, ++ uint16_t group_identifier_from, + +- int8_t scene_identifier_from, ++ uint8_t scene_identifier_from, + +- uint8_t * group_identifier_to, ++ uint16_t group_identifier_to, + +- int8_t scene_identifier_to ++ uint8_t scene_identifier_to + + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_response_callback_t)( +@@ -4585,16 +4585,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_copy_scene_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + zclStatus status, + +- uint8_t * group_identifier_from, ++ uint16_t group_identifier_from, + +- int8_t scene_identifier_from ++ uint8_t scene_identifier_from + + ); + + typedef struct { +- int8_t scene_count; +- int8_t current_scene; +- uint8_t * current_group; ++ uint8_t scene_count; ++ uint8_t current_scene; ++ uint16_t current_group; + bool scene_valid; + uint8_t name_support; + uint64_t last_configured_by; +@@ -4632,18 +4632,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_force_read_attributes_callback_t)( + * @brief Command fields for Scenes/AddScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + +- int16_t transition_time; ++ uint16_t transition_time; + +- uint8_t * scene_name; ++ const char* scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; + +- int8_t transition_time100ms; ++ uint8_t transition_time100ms; + } uic_mqtt_dotdot_scenes_command_add_scene_fields_t; + + /** +@@ -4652,18 +4652,18 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_add_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/ViewScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_view_scene_fields_t; + + /** +@@ -4672,13 +4672,13 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + +- int16_t transition_time; ++ uint16_t transition_time; + +- uint8_t * scene_name; ++ const char* scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4688,9 +4688,9 @@ typedef struct { + * @brief Command fields for Scenes/RemoveScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_remove_scene_fields_t; + + /** +@@ -4699,16 +4699,16 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_remove_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/RemoveAllScenes + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + } uic_mqtt_dotdot_scenes_command_remove_all_scenes_fields_t; + + /** +@@ -4717,16 +4717,16 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + } uic_mqtt_dotdot_scenes_command_remove_all_scenes_response_fields_t; + + /** + * @brief Command fields for Scenes/StoreScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_store_scene_fields_t; + + /** +@@ -4735,27 +4735,27 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_store_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/RecallScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + +- int16_t transition_time; ++ uint16_t transition_time; + } uic_mqtt_dotdot_scenes_command_recall_scene_fields_t; + + /** + * @brief Command fields for Scenes/GetSceneMembership + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + } uic_mqtt_dotdot_scenes_command_get_scene_membership_fields_t; + + /** +@@ -4764,25 +4764,25 @@ typedef struct { + typedef struct { + zclStatus status; + +- int8_t capacity; ++ uint8_t capacity; + +- uint8_t * groupid; ++ uint16_t groupid; + + uint8_t scene_list_count; +- const int8_t *scene_list; ++ const uint8_t *scene_list; + } uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t; + + /** + * @brief Command fields for Scenes/EnhancedAddScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + +- int16_t transition_time; ++ uint16_t transition_time; + +- uint8_t * scene_name; ++ const char* scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4794,18 +4794,18 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_enhanced_add_scene_response_fields_t; + + /** + * @brief Command fields for Scenes/EnhancedViewScene + */ + typedef struct { +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + } uic_mqtt_dotdot_scenes_command_enhanced_view_scene_fields_t; + + /** +@@ -4814,13 +4814,13 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * groupid; ++ uint16_t groupid; + +- int8_t sceneid; ++ uint8_t sceneid; + +- int16_t transition_time; ++ uint16_t transition_time; + +- uint8_t * scene_name; ++ const char* scene_name; + + uint8_t extension_field_sets_count; + const SExtensionFieldSetList *extension_field_sets; +@@ -4832,13 +4832,13 @@ typedef struct { + typedef struct { + uint8_t mode; + +- uint8_t * group_identifier_from; ++ uint16_t group_identifier_from; + +- int8_t scene_identifier_from; ++ uint8_t scene_identifier_from; + +- uint8_t * group_identifier_to; ++ uint16_t group_identifier_to; + +- int8_t scene_identifier_to; ++ uint8_t scene_identifier_to; + } uic_mqtt_dotdot_scenes_command_copy_scene_fields_t; + + /** +@@ -4847,9 +4847,9 @@ typedef struct { + typedef struct { + zclStatus status; + +- uint8_t * group_identifier_from; ++ uint16_t group_identifier_from; + +- int8_t scene_identifier_from; ++ uint8_t scene_identifier_from; + } uic_mqtt_dotdot_scenes_command_copy_scene_response_fields_t; + + +@@ -5675,7 +5675,7 @@ void uic_mqtt_dotdot_clear_scenes_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_scenes_scene_count_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5705,7 +5705,7 @@ sl_status_t uic_mqtt_dotdot_scenes_scene_count_unretain( + */ + sl_status_t uic_mqtt_dotdot_scenes_current_scene_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5735,7 +5735,7 @@ sl_status_t uic_mqtt_dotdot_scenes_current_scene_unretain( + */ + sl_status_t uic_mqtt_dotdot_scenes_current_group_publish( + const char *base_topic, +- uint8_t * value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -5941,7 +5941,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_off_with_effect_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + OffWithEffectEffectIdentifier effect_identifier, + +- int8_t effect_variant ++ uint8_t effect_variant + + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_on_with_recall_global_scene_callback_t)( +@@ -5955,17 +5955,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_on_with_timed_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t on_off_control, + +- int16_t on_time, ++ uint16_t on_time, + +- int16_t off_wait_time ++ uint16_t off_wait_time + + ); + + typedef struct { + bool on_off; + bool global_scene_control; +- int16_t on_time; +- int16_t off_wait_time; ++ uint16_t on_time; ++ uint16_t off_wait_time; + uint8_t start_up_on_off; + } uic_mqtt_dotdot_on_off_state_t; + +@@ -5999,7 +5999,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_force_read_attributes_callback_t)( + typedef struct { + OffWithEffectEffectIdentifier effect_identifier; + +- int8_t effect_variant; ++ uint8_t effect_variant; + } uic_mqtt_dotdot_on_off_command_off_with_effect_fields_t; + + /** +@@ -6008,9 +6008,9 @@ typedef struct { + typedef struct { + uint8_t on_off_control; + +- int16_t on_time; ++ uint16_t on_time; + +- int16_t off_wait_time; ++ uint16_t off_wait_time; + } uic_mqtt_dotdot_on_off_command_on_with_timed_off_fields_t; + + +@@ -6376,7 +6376,7 @@ sl_status_t uic_mqtt_dotdot_on_off_global_scene_control_unretain( + */ + sl_status_t uic_mqtt_dotdot_on_off_on_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -6406,7 +6406,7 @@ sl_status_t uic_mqtt_dotdot_on_off_on_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_on_off_off_wait_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -6503,9 +6503,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t level, ++ uint8_t level, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -6518,7 +6518,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -6531,9 +6531,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_step_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -6553,9 +6553,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_level_with_on_off_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t level, ++ uint8_t level, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -6568,7 +6568,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_with_on_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -6581,9 +6581,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_step_with_on_off_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + MoveStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -6603,25 +6603,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_move_to_closest_frequency_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t frequency ++ uint16_t frequency + + ); + + typedef struct { +- int8_t current_level; +- int16_t remaining_time; +- int8_t min_level; +- int8_t max_level; +- int16_t current_frequency; +- int16_t min_frequency; +- int16_t max_frequency; ++ uint8_t current_level; ++ uint16_t remaining_time; ++ uint8_t min_level; ++ uint8_t max_level; ++ uint16_t current_frequency; ++ uint16_t min_frequency; ++ uint16_t max_frequency; + uint8_t options; +- int16_t on_off_transition_time; +- int8_t on_level; +- int16_t on_transition_time; +- int16_t off_transition_time; +- int16_t default_move_rate; +- int8_t start_up_current_level; ++ uint16_t on_off_transition_time; ++ uint8_t on_level; ++ uint16_t on_transition_time; ++ uint16_t off_transition_time; ++ uint16_t default_move_rate; ++ uint8_t start_up_current_level; + } uic_mqtt_dotdot_level_state_t; + + typedef struct { +@@ -6661,9 +6661,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_force_read_attributes_callback_t)( + * @brief Command fields for Level/MoveToLevel + */ + typedef struct { +- int8_t level; ++ uint8_t level; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -6676,7 +6676,7 @@ typedef struct { + typedef struct { + MoveStepMode move_mode; + +- int8_t rate; ++ uint8_t rate; + + uint8_t options_mask; + +@@ -6689,9 +6689,9 @@ typedef struct { + typedef struct { + MoveStepMode step_mode; + +- int8_t step_size; ++ uint8_t step_size; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -6711,9 +6711,9 @@ typedef struct { + * @brief Command fields for Level/MoveToLevelWithOnOff + */ + typedef struct { +- int8_t level; ++ uint8_t level; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -6726,7 +6726,7 @@ typedef struct { + typedef struct { + MoveStepMode move_mode; + +- int8_t rate; ++ uint8_t rate; + + uint8_t options_mask; + +@@ -6739,9 +6739,9 @@ typedef struct { + typedef struct { + MoveStepMode step_mode; + +- int8_t step_size; ++ uint8_t step_size; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -6761,7 +6761,7 @@ typedef struct { + * @brief Command fields for Level/MoveToClosestFrequency + */ + typedef struct { +- int16_t frequency; ++ uint16_t frequency; + } uic_mqtt_dotdot_level_command_move_to_closest_frequency_fields_t; + + +@@ -7187,7 +7187,7 @@ void uic_mqtt_dotdot_clear_level_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_level_current_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7217,7 +7217,7 @@ sl_status_t uic_mqtt_dotdot_level_current_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_remaining_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7247,7 +7247,7 @@ sl_status_t uic_mqtt_dotdot_level_remaining_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7277,7 +7277,7 @@ sl_status_t uic_mqtt_dotdot_level_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7307,7 +7307,7 @@ sl_status_t uic_mqtt_dotdot_level_max_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_current_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7337,7 +7337,7 @@ sl_status_t uic_mqtt_dotdot_level_current_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_min_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7367,7 +7367,7 @@ sl_status_t uic_mqtt_dotdot_level_min_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_max_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7427,7 +7427,7 @@ sl_status_t uic_mqtt_dotdot_level_options_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7457,7 +7457,7 @@ sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7487,7 +7487,7 @@ sl_status_t uic_mqtt_dotdot_level_on_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_on_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7517,7 +7517,7 @@ sl_status_t uic_mqtt_dotdot_level_on_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_off_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7547,7 +7547,7 @@ sl_status_t uic_mqtt_dotdot_level_off_transition_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_default_move_rate_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7577,7 +7577,7 @@ sl_status_t uic_mqtt_dotdot_level_default_move_rate_unretain( + */ + sl_status_t uic_mqtt_dotdot_level_start_up_current_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -7646,7 +7646,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_alarm_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t alarm_code, + +- uint8_t cluster_identifier ++ uint16_t cluster_identifier + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_alarm_callback_t)( +@@ -7655,7 +7655,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_alarm_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t alarm_code, + +- uint8_t cluster_identifier ++ uint16_t cluster_identifier + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_all_alarms_callback_t)( +@@ -7671,9 +7671,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_get_alarm_response_callback_t)( + + uint8_t alarm_code, + +- uint8_t cluster_identifier, ++ uint16_t cluster_identifier, + +- int32_t time_stamp ++ uint32_t time_stamp + + ); + typedef sl_status_t (*uic_mqtt_dotdot_alarms_get_alarm_callback_t)( +@@ -7688,7 +7688,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_reset_alarm_log_callback_t)( + ); + + typedef struct { +- int16_t alarm_count; ++ uint16_t alarm_count; + } uic_mqtt_dotdot_alarms_state_t; + + typedef struct { +@@ -7717,7 +7717,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_force_read_attributes_callback_t)( + typedef struct { + uint8_t alarm_code; + +- uint8_t cluster_identifier; ++ uint16_t cluster_identifier; + } uic_mqtt_dotdot_alarms_command_reset_alarm_fields_t; + + /** +@@ -7726,7 +7726,7 @@ typedef struct { + typedef struct { + uint8_t alarm_code; + +- uint8_t cluster_identifier; ++ uint16_t cluster_identifier; + } uic_mqtt_dotdot_alarms_command_alarm_fields_t; + + /** +@@ -7737,9 +7737,9 @@ typedef struct { + + uint8_t alarm_code; + +- uint8_t cluster_identifier; ++ uint16_t cluster_identifier; + +- int32_t time_stamp; ++ uint32_t time_stamp; + } uic_mqtt_dotdot_alarms_command_get_alarm_response_fields_t; + + +@@ -8045,7 +8045,7 @@ void uic_mqtt_dotdot_clear_alarms_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_alarms_alarm_count_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8110,16 +8110,16 @@ void uic_mqtt_dotdot_alarms_publish_empty_supported_commands( + // Callback types used by the time cluster + + typedef struct { +- uint8_t time; ++ uint32_t time; + uint8_t time_status; + int32_t time_zone; +- int32_t dst_start; +- int32_t dst_end; ++ uint32_t dst_start; ++ uint32_t dst_end; + int32_t dst_shift; +- int32_t standard_time; +- int32_t local_time; +- uint8_t last_set_time; +- uint8_t valid_until_time; ++ uint32_t standard_time; ++ uint32_t local_time; ++ uint32_t last_set_time; ++ uint32_t valid_until_time; + } uic_mqtt_dotdot_time_state_t; + + typedef struct { +@@ -8214,7 +8214,7 @@ void uic_mqtt_dotdot_clear_time_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_time_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8304,7 +8304,7 @@ sl_status_t uic_mqtt_dotdot_time_time_zone_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_dst_start_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8334,7 +8334,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_start_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_dst_end_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8394,7 +8394,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_shift_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_standard_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8424,7 +8424,7 @@ sl_status_t uic_mqtt_dotdot_time_standard_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_local_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8454,7 +8454,7 @@ sl_status_t uic_mqtt_dotdot_time_local_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_last_set_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8484,7 +8484,7 @@ sl_status_t uic_mqtt_dotdot_time_last_set_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_time_valid_until_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8558,7 +8558,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_check_in_response_callback_t) + uic_mqtt_dotdot_callback_call_type_t call_type, + bool start_fast_polling, + +- int16_t fast_poll_timeout ++ uint16_t fast_poll_timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_fast_poll_stop_callback_t)( +@@ -8570,25 +8570,25 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_set_long_poll_interval_callba + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int32_t new_long_poll_interval ++ uint32_t new_long_poll_interval + + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t new_short_poll_interval ++ uint16_t new_short_poll_interval + + ); + + typedef struct { +- int32_t check_in_interval; +- int32_t long_poll_interval; +- int16_t short_poll_interval; +- int16_t fast_poll_timeout; +- int32_t check_in_interval_min; +- int32_t long_poll_interval_min; +- int16_t fast_poll_timeout_max; ++ uint32_t check_in_interval; ++ uint32_t long_poll_interval; ++ uint16_t short_poll_interval; ++ uint16_t fast_poll_timeout; ++ uint32_t check_in_interval_min; ++ uint32_t long_poll_interval_min; ++ uint16_t fast_poll_timeout_max; + } uic_mqtt_dotdot_poll_control_state_t; + + typedef struct { +@@ -8623,21 +8623,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_force_read_attributes_callbac + typedef struct { + bool start_fast_polling; + +- int16_t fast_poll_timeout; ++ uint16_t fast_poll_timeout; + } uic_mqtt_dotdot_poll_control_command_check_in_response_fields_t; + + /** + * @brief Command fields for PollControl/SetLongPollInterval + */ + typedef struct { +- int32_t new_long_poll_interval; ++ uint32_t new_long_poll_interval; + } uic_mqtt_dotdot_poll_control_command_set_long_poll_interval_fields_t; + + /** + * @brief Command fields for PollControl/SetShortPollInterval + */ + typedef struct { +- int16_t new_short_poll_interval; ++ uint16_t new_short_poll_interval; + } uic_mqtt_dotdot_poll_control_command_set_short_poll_interval_fields_t; + + +@@ -8903,7 +8903,7 @@ void uic_mqtt_dotdot_clear_poll_control_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8933,7 +8933,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8963,7 +8963,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -8993,7 +8993,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9023,7 +9023,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9053,7 +9053,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9083,7 +9083,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9148,10 +9148,10 @@ void uic_mqtt_dotdot_poll_control_publish_empty_supported_commands( + // Callback types used by the shade_configuration cluster + + typedef struct { +- int16_t physical_closed_limit; +- int8_t motor_step_size; ++ uint16_t physical_closed_limit; ++ uint8_t motor_step_size; + uint8_t status; +- int16_t closed_limit; ++ uint16_t closed_limit; + uint8_t mode; + } uic_mqtt_dotdot_shade_configuration_state_t; + +@@ -9242,7 +9242,7 @@ void uic_mqtt_dotdot_clear_shade_configuration_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9272,7 +9272,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9332,7 +9332,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -9429,7 +9429,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_lock_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_lock_door_response_callback_t)( +@@ -9443,7 +9443,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_door_response_callback_t)( +@@ -9457,7 +9457,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_toggle_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_toggle_response_callback_t)( +@@ -9471,9 +9471,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t timeout_in_seconds, ++ uint16_t timeout_in_seconds, + +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unlock_with_timeout_response_callback_t)( +@@ -9487,39 +9487,39 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_log_record_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t log_index ++ uint16_t log_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_log_record_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t log_entryid, ++ uint16_t log_entryid, + +- int32_t timestamp, ++ uint32_t timestamp, + + GetLogRecordResponseEventType event_type, + + DrlkOperEventSource source_operation_event, + +- int8_t event_id_or_alarm_code, ++ uint8_t event_id_or_alarm_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin ++ const char* pin + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t pin ++ const char* pin + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_pin_code_response_callback_t)( +@@ -9533,27 +9533,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t code ++ const char* code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_pin_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_pin_code_response_callback_t)( +@@ -9579,7 +9579,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_status_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status + +@@ -9595,14 +9595,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_status_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_status_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status + +@@ -9611,19 +9611,19 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid, ++ uint16_t userid, + + uint8_t days_mask, + +- int8_t start_hour, ++ uint8_t start_hour, + +- int8_t start_minute, ++ uint8_t start_minute, + +- int8_t end_hour, ++ uint8_t end_hour, + +- int8_t end_minute ++ uint8_t end_minute + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_weekday_schedule_response_callback_t)( +@@ -9637,39 +9637,39 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t scheduleid, ++ uint8_t scheduleid, + +- int16_t userid, ++ uint16_t userid, + + zclStatus status, + + uint8_t days_mask, + +- int8_t start_hour, ++ uint8_t start_hour, + +- int8_t start_minute, ++ uint8_t start_minute, + +- int8_t end_hour, ++ uint8_t end_hour, + +- int8_t end_minute ++ uint8_t end_minute + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_weekday_schedule_response_callback_t)( +@@ -9683,13 +9683,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid, ++ uint16_t userid, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time ++ uint32_t local_end_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_year_day_schedule_response_callback_t)( +@@ -9703,33 +9703,33 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_t + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t scheduleid, ++ uint8_t scheduleid, + +- int16_t userid, ++ uint16_t userid, + + zclStatus status, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time ++ uint32_t local_end_time + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_year_day_schedule_response_callback_t)( +@@ -9743,11 +9743,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * holiday_scheduleid, ++ uint8_t holiday_scheduleid, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time, ++ uint32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -9763,20 +9763,20 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_t) + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * holiday_scheduleid ++ uint8_t holiday_scheduleid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t holiday_scheduleid, ++ uint8_t holiday_scheduleid, + + zclStatus status, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time, ++ uint32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -9785,7 +9785,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * holiday_scheduleid ++ uint8_t holiday_scheduleid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_holiday_schedule_response_callback_t)( +@@ -9799,7 +9799,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_type_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkUserType user_type + +@@ -9815,14 +9815,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_type_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_type_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserType user_type + +@@ -9831,13 +9831,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t rfid_code ++ const char* rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_rfid_code_response_callback_t)( +@@ -9851,27 +9851,27 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t rfid_code ++ const char* rfid_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t * userid ++ uint16_t userid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_rfid_code_response_callback_t)( +@@ -9899,11 +9899,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_user_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + DataOperationTypeEnum operation_type, + +- int16_t user_index, ++ uint16_t user_index, + + const char* user_name, + +- int32_t user_uniqueid, ++ uint32_t user_uniqueid, + + DrlkSettableUserStatus user_status, + +@@ -9916,7 +9916,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_index ++ uint16_t user_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_get_user_response_callback_t)( +@@ -9928,7 +9928,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_clear_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_index ++ uint16_t user_index + + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_operating_event_notification_callback_t)( +@@ -9939,11 +9939,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_operating_event_notification_cal + + OperatingEventNotificationOperationEventCode operation_event_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin, ++ const char* pin, + +- int32_t local_time, ++ uint32_t local_time, + + const char* data + +@@ -9956,15 +9956,15 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_programming_event_notification_c + + ProgrammingEventNotificationProgramEventCode program_event_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin, ++ const char* pin, + + DrlkUserType user_type, + + DrlkUserStatus user_status, + +- int32_t local_time, ++ uint32_t local_time, + + const char* data + +@@ -9977,9 +9977,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_set_credential_callback_t)( + + CredentialStruct credential, + +- uint8_t credential_data, ++ const char* credential_data, + +- int16_t user_index, ++ uint16_t user_index, + + DrlkSettableUserStatus user_status, + +@@ -10014,7 +10014,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_unbolt_door_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t pin_code ++ const char* pin_code + + ); + +@@ -10023,27 +10023,27 @@ typedef struct { + uint8_t lock_type; + bool actuator_enabled; + uint8_t door_state; +- int32_t door_open_events; +- int32_t door_closed_events; +- int16_t open_period; +- int16_t number_of_log_records_supported; +- int16_t number_of_total_users_supported; +- int16_t number_of_pin_users_supported; +- int16_t number_of_rfid_users_supported; +- int8_t number_of_week_day_schedules_supported_per_user; +- int8_t number_of_year_day_schedules_supported_per_user; +- int8_t number_of_holiday_schedules_supported; +- int8_t max_pin_code_length; +- int8_t min_pin_code_length; +- int8_t max_rfid_code_length; +- int8_t min_rfid_code_length; ++ uint32_t door_open_events; ++ uint32_t door_closed_events; ++ uint16_t open_period; ++ uint16_t number_of_log_records_supported; ++ uint16_t number_of_total_users_supported; ++ uint16_t number_of_pin_users_supported; ++ uint16_t number_of_rfid_users_supported; ++ uint8_t number_of_week_day_schedules_supported_per_user; ++ uint8_t number_of_year_day_schedules_supported_per_user; ++ uint8_t number_of_holiday_schedules_supported; ++ uint8_t max_pin_code_length; ++ uint8_t min_pin_code_length; ++ uint8_t max_rfid_code_length; ++ uint8_t min_rfid_code_length; + uint8_t credential_rules_support; +- int8_t number_of_credentials_supported_per_user; ++ uint8_t number_of_credentials_supported_per_user; + bool enable_logging; + const char* language; +- int8_t led_settings; +- int32_t auto_relock_time; +- int8_t sound_volume; ++ uint8_t led_settings; ++ uint32_t auto_relock_time; ++ uint8_t sound_volume; + uint8_t operating_mode; + uint16_t supported_operating_modes; + uint16_t default_configuration_register; +@@ -10052,12 +10052,12 @@ typedef struct { + bool enable_inside_statusled; + bool enable_privacy_mode_button; + uint8_t local_programming_features; +- int8_t wrong_code_entry_limit; +- int8_t user_code_temporary_disable_time; ++ uint8_t wrong_code_entry_limit; ++ uint8_t user_code_temporary_disable_time; + bool send_pin_over_the_air; + bool require_pi_nfor_rf_operation; + uint8_t security_level; +- int16_t expiring_user_timeout; ++ uint16_t expiring_user_timeout; + uint16_t alarm_mask; + uint16_t keypad_operation_event_mask; + uint16_t rf_operation_event_mask; +@@ -10140,7 +10140,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_force_read_attributes_callback_t + * @brief Command fields for DoorLock/LockDoor + */ + typedef struct { +- uint8_t pin_or_rfid_code; ++ const char* pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_lock_door_fields_t; + + /** +@@ -10154,7 +10154,7 @@ typedef struct { + * @brief Command fields for DoorLock/UnlockDoor + */ + typedef struct { +- uint8_t pin_or_rfid_code; ++ const char* pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_unlock_door_fields_t; + + /** +@@ -10168,7 +10168,7 @@ typedef struct { + * @brief Command fields for DoorLock/Toggle + */ + typedef struct { +- uint8_t pin_or_rfid_code; ++ const char* pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_toggle_fields_t; + + /** +@@ -10182,9 +10182,9 @@ typedef struct { + * @brief Command fields for DoorLock/UnlockWithTimeout + */ + typedef struct { +- int16_t timeout_in_seconds; ++ uint16_t timeout_in_seconds; + +- uint8_t pin_or_rfid_code; ++ const char* pin_or_rfid_code; + } uic_mqtt_dotdot_door_lock_command_unlock_with_timeout_fields_t; + + /** +@@ -10198,39 +10198,39 @@ typedef struct { + * @brief Command fields for DoorLock/GetLogRecord + */ + typedef struct { +- int16_t log_index; ++ uint16_t log_index; + } uic_mqtt_dotdot_door_lock_command_get_log_record_fields_t; + + /** + * @brief Command fields for DoorLock/GetLogRecordResponse + */ + typedef struct { +- int16_t log_entryid; ++ uint16_t log_entryid; + +- int32_t timestamp; ++ uint32_t timestamp; + + GetLogRecordResponseEventType event_type; + + DrlkOperEventSource source_operation_event; + +- int8_t event_id_or_alarm_code; ++ uint8_t event_id_or_alarm_code; + +- int16_t userid; ++ uint16_t userid; + +- uint8_t pin; ++ const char* pin; + } uic_mqtt_dotdot_door_lock_command_get_log_record_response_fields_t; + + /** + * @brief Command fields for DoorLock/SetPINCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + + DrlkSettableUserStatus user_status; + + DrlkUserType user_type; + +- uint8_t pin; ++ const char* pin; + } uic_mqtt_dotdot_door_lock_command_set_pin_code_fields_t; + + /** +@@ -10244,27 +10244,27 @@ typedef struct { + * @brief Command fields for DoorLock/GetPINCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_pin_code_fields_t; + + /** + * @brief Command fields for DoorLock/GetPINCodeResponse + */ + typedef struct { +- int16_t userid; ++ uint16_t userid; + + DrlkUserStatus user_status; + + DrlkUserType user_type; + +- uint8_t code; ++ const char* code; + } uic_mqtt_dotdot_door_lock_command_get_pin_code_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearPINCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_clear_pin_code_fields_t; + + /** +@@ -10285,7 +10285,7 @@ typedef struct { + * @brief Command fields for DoorLock/SetUserStatus + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + + DrlkSettableUserStatus user_status; + } uic_mqtt_dotdot_door_lock_command_set_user_status_fields_t; +@@ -10301,14 +10301,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUserStatus + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_user_status_fields_t; + + /** + * @brief Command fields for DoorLock/GetUserStatusResponse + */ + typedef struct { +- int16_t userid; ++ uint16_t userid; + + DrlkUserStatus user_status; + } uic_mqtt_dotdot_door_lock_command_get_user_status_response_fields_t; +@@ -10317,19 +10317,19 @@ typedef struct { + * @brief Command fields for DoorLock/SetWeekdaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + + uint8_t days_mask; + +- int8_t start_hour; ++ uint8_t start_hour; + +- int8_t start_minute; ++ uint8_t start_minute; + +- int8_t end_hour; ++ uint8_t end_hour; + +- int8_t end_minute; ++ uint8_t end_minute; + } uic_mqtt_dotdot_door_lock_command_set_weekday_schedule_fields_t; + + /** +@@ -10343,39 +10343,39 @@ typedef struct { + * @brief Command fields for DoorLock/GetWeekdaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetWeekdayScheduleResponse + */ + typedef struct { +- int8_t scheduleid; ++ uint8_t scheduleid; + +- int16_t userid; ++ uint16_t userid; + + zclStatus status; + + uint8_t days_mask; + +- int8_t start_hour; ++ uint8_t start_hour; + +- int8_t start_minute; ++ uint8_t start_minute; + +- int8_t end_hour; ++ uint8_t end_hour; + +- int8_t end_minute; ++ uint8_t end_minute; + } uic_mqtt_dotdot_door_lock_command_get_weekday_schedule_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearWeekdaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_clear_weekday_schedule_fields_t; + + /** +@@ -10389,13 +10389,13 @@ typedef struct { + * @brief Command fields for DoorLock/SetYearDaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + +- int32_t local_start_time; ++ uint32_t local_start_time; + +- int32_t local_end_time; ++ uint32_t local_end_time; + } uic_mqtt_dotdot_door_lock_command_set_year_day_schedule_fields_t; + + /** +@@ -10409,33 +10409,33 @@ typedef struct { + * @brief Command fields for DoorLock/GetYearDaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetYearDayScheduleResponse + */ + typedef struct { +- int8_t scheduleid; ++ uint8_t scheduleid; + +- int16_t userid; ++ uint16_t userid; + + zclStatus status; + +- int32_t local_start_time; ++ uint32_t local_start_time; + +- int32_t local_end_time; ++ uint32_t local_end_time; + } uic_mqtt_dotdot_door_lock_command_get_year_day_schedule_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearYearDaySchedule + */ + typedef struct { +- uint8_t * scheduleid; ++ uint8_t scheduleid; + +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_clear_year_day_schedule_fields_t; + + /** +@@ -10449,11 +10449,11 @@ typedef struct { + * @brief Command fields for DoorLock/SetHolidaySchedule + */ + typedef struct { +- uint8_t * holiday_scheduleid; ++ uint8_t holiday_scheduleid; + +- int32_t local_start_time; ++ uint32_t local_start_time; + +- int32_t local_end_time; ++ uint32_t local_end_time; + + DrlkOperMode operating_mode_during_holiday; + } uic_mqtt_dotdot_door_lock_command_set_holiday_schedule_fields_t; +@@ -10469,20 +10469,20 @@ typedef struct { + * @brief Command fields for DoorLock/GetHolidaySchedule + */ + typedef struct { +- uint8_t * holiday_scheduleid; ++ uint8_t holiday_scheduleid; + } uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_fields_t; + + /** + * @brief Command fields for DoorLock/GetHolidayScheduleResponse + */ + typedef struct { +- int8_t holiday_scheduleid; ++ uint8_t holiday_scheduleid; + + zclStatus status; + +- int32_t local_start_time; ++ uint32_t local_start_time; + +- int32_t local_end_time; ++ uint32_t local_end_time; + + DrlkOperMode operating_mode_during_holiday; + } uic_mqtt_dotdot_door_lock_command_get_holiday_schedule_response_fields_t; +@@ -10491,7 +10491,7 @@ typedef struct { + * @brief Command fields for DoorLock/ClearHolidaySchedule + */ + typedef struct { +- uint8_t * holiday_scheduleid; ++ uint8_t holiday_scheduleid; + } uic_mqtt_dotdot_door_lock_command_clear_holiday_schedule_fields_t; + + /** +@@ -10505,7 +10505,7 @@ typedef struct { + * @brief Command fields for DoorLock/SetUserType + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + + DrlkUserType user_type; + } uic_mqtt_dotdot_door_lock_command_set_user_type_fields_t; +@@ -10521,14 +10521,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUserType + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_user_type_fields_t; + + /** + * @brief Command fields for DoorLock/GetUserTypeResponse + */ + typedef struct { +- int16_t userid; ++ uint16_t userid; + + DrlkUserType user_type; + } uic_mqtt_dotdot_door_lock_command_get_user_type_response_fields_t; +@@ -10537,13 +10537,13 @@ typedef struct { + * @brief Command fields for DoorLock/SetRFIDCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + + DrlkSettableUserStatus user_status; + + DrlkUserType user_type; + +- uint8_t rfid_code; ++ const char* rfid_code; + } uic_mqtt_dotdot_door_lock_command_set_rfid_code_fields_t; + + /** +@@ -10557,27 +10557,27 @@ typedef struct { + * @brief Command fields for DoorLock/GetRFIDCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_get_rfid_code_fields_t; + + /** + * @brief Command fields for DoorLock/GetRFIDCodeResponse + */ + typedef struct { +- int16_t userid; ++ uint16_t userid; + + DrlkUserStatus user_status; + + DrlkUserType user_type; + +- uint8_t rfid_code; ++ const char* rfid_code; + } uic_mqtt_dotdot_door_lock_command_get_rfid_code_response_fields_t; + + /** + * @brief Command fields for DoorLock/ClearRFIDCode + */ + typedef struct { +- uint8_t * userid; ++ uint16_t userid; + } uic_mqtt_dotdot_door_lock_command_clear_rfid_code_fields_t; + + /** +@@ -10600,11 +10600,11 @@ typedef struct { + typedef struct { + DataOperationTypeEnum operation_type; + +- int16_t user_index; ++ uint16_t user_index; + + const char* user_name; + +- int32_t user_uniqueid; ++ uint32_t user_uniqueid; + + DrlkSettableUserStatus user_status; + +@@ -10617,14 +10617,14 @@ typedef struct { + * @brief Command fields for DoorLock/GetUser + */ + typedef struct { +- int16_t user_index; ++ uint16_t user_index; + } uic_mqtt_dotdot_door_lock_command_get_user_fields_t; + + /** + * @brief Command fields for DoorLock/ClearUser + */ + typedef struct { +- int16_t user_index; ++ uint16_t user_index; + } uic_mqtt_dotdot_door_lock_command_clear_user_fields_t; + + /** +@@ -10635,11 +10635,11 @@ typedef struct { + + OperatingEventNotificationOperationEventCode operation_event_code; + +- int16_t userid; ++ uint16_t userid; + +- uint8_t pin; ++ const char* pin; + +- int32_t local_time; ++ uint32_t local_time; + + const char* data; + } uic_mqtt_dotdot_door_lock_command_operating_event_notification_fields_t; +@@ -10652,15 +10652,15 @@ typedef struct { + + ProgrammingEventNotificationProgramEventCode program_event_code; + +- int16_t userid; ++ uint16_t userid; + +- uint8_t pin; ++ const char* pin; + + DrlkUserType user_type; + + DrlkUserStatus user_status; + +- int32_t local_time; ++ uint32_t local_time; + + const char* data; + } uic_mqtt_dotdot_door_lock_command_programming_event_notification_fields_t; +@@ -10673,9 +10673,9 @@ typedef struct { + + CredentialStruct credential; + +- uint8_t credential_data; ++ const char* credential_data; + +- int16_t user_index; ++ uint16_t user_index; + + DrlkSettableUserStatus user_status; + +@@ -10700,7 +10700,7 @@ typedef struct { + * @brief Command fields for DoorLock/UnboltDoor + */ + typedef struct { +- uint8_t pin_code; ++ const char* pin_code; + } uic_mqtt_dotdot_door_lock_command_unbolt_door_fields_t; + + +@@ -13446,7 +13446,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_state_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13476,7 +13476,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13506,7 +13506,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_open_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13536,7 +13536,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_open_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13566,7 +13566,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13596,7 +13596,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13626,7 +13626,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13656,7 +13656,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13686,7 +13686,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13716,7 +13716,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13746,7 +13746,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_unre + */ + sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13776,7 +13776,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13806,7 +13806,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13836,7 +13836,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13896,7 +13896,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_credential_rules_support_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -13986,7 +13986,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_language_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_led_settings_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14016,7 +14016,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_led_settings_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14046,7 +14046,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_sound_volume_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14316,7 +14316,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_local_programming_features_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14346,7 +14346,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14466,7 +14466,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_security_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -14818,52 +14818,52 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t lift_value ++ uint16_t lift_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t percentage_lift_value ++ uint8_t percentage_lift_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t tilt_value ++ uint16_t tilt_value + + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t percentage_tilt_value ++ uint8_t percentage_tilt_value + + ); + + typedef struct { + uint8_t window_covering_type; +- int16_t physical_closed_limit_lift; +- int16_t physical_closed_limit_tilt; +- int16_t current_position_lift; +- int16_t current_position_tilt; +- int16_t number_of_actuations_lift; +- int16_t number_of_actuations_tilt; ++ uint16_t physical_closed_limit_lift; ++ uint16_t physical_closed_limit_tilt; ++ uint16_t current_position_lift; ++ uint16_t current_position_tilt; ++ uint16_t number_of_actuations_lift; ++ uint16_t number_of_actuations_tilt; + uint8_t config_or_status; +- int8_t current_position_lift_percentage; +- int8_t current_position_tilt_percentage; +- int16_t installed_open_limit_lift; +- int16_t installed_closed_limit_lift; +- int16_t installed_open_limit_tilt; +- int16_t installed_closed_limit_tilt; +- int16_t velocity_lift; +- int16_t acceleration_time_lift; +- int16_t deceleration_time_lift; ++ uint8_t current_position_lift_percentage; ++ uint8_t current_position_tilt_percentage; ++ uint16_t installed_open_limit_lift; ++ uint16_t installed_closed_limit_lift; ++ uint16_t installed_open_limit_tilt; ++ uint16_t installed_closed_limit_tilt; ++ uint16_t velocity_lift; ++ uint16_t acceleration_time_lift; ++ uint16_t deceleration_time_lift; + uint8_t mode; +- uint8_t intermediate_setpoints_lift; +- uint8_t intermediate_setpoints_tilt; ++ const char* intermediate_setpoints_lift; ++ const char* intermediate_setpoints_tilt; + } uic_mqtt_dotdot_window_covering_state_t; + + typedef struct { +@@ -14909,28 +14909,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_force_read_attributes_call + * @brief Command fields for WindowCovering/GoToLiftValue + */ + typedef struct { +- int16_t lift_value; ++ uint16_t lift_value; + } uic_mqtt_dotdot_window_covering_command_go_to_lift_value_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToLiftPercentage + */ + typedef struct { +- int8_t percentage_lift_value; ++ uint8_t percentage_lift_value; + } uic_mqtt_dotdot_window_covering_command_go_to_lift_percentage_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToTiltValue + */ + typedef struct { +- int16_t tilt_value; ++ uint16_t tilt_value; + } uic_mqtt_dotdot_window_covering_command_go_to_tilt_value_fields_t; + + /** + * @brief Command fields for WindowCovering/GoToTiltPercentage + */ + typedef struct { +- int8_t percentage_tilt_value; ++ uint8_t percentage_tilt_value; + } uic_mqtt_dotdot_window_covering_command_go_to_tilt_percentage_fields_t; + + +@@ -15306,7 +15306,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_window_covering_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15336,7 +15336,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15366,7 +15366,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15396,7 +15396,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15426,7 +15426,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15456,7 +15456,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15516,7 +15516,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_config_or_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15546,7 +15546,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_unr + */ + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15576,7 +15576,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_unr + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15606,7 +15606,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15636,7 +15636,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15666,7 +15666,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15696,7 +15696,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15726,7 +15726,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15756,7 +15756,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15816,7 +15816,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15846,7 +15846,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_unretain + */ + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -15913,7 +15913,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_go_to_percent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t percent_open ++ uint8_t percent_open + + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_stop_callback_t)( +@@ -15926,13 +15926,13 @@ typedef struct { + uint8_t moving_state; + uint16_t safety_status; + uint8_t capabilities; +- int16_t open_events; +- int16_t close_events; +- int16_t command_open_events; +- int16_t command_close_events; +- int16_t open_period; +- int16_t close_period; +- int8_t barrier_position; ++ uint16_t open_events; ++ uint16_t close_events; ++ uint16_t command_open_events; ++ uint16_t command_close_events; ++ uint16_t open_period; ++ uint16_t close_period; ++ uint8_t barrier_position; + } uic_mqtt_dotdot_barrier_control_state_t; + + typedef struct { +@@ -15968,7 +15968,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_force_read_attributes_call + * @brief Command fields for BarrierControl/GoToPercent + */ + typedef struct { +- int8_t percent_open; ++ uint8_t percent_open; + } uic_mqtt_dotdot_barrier_control_command_go_to_percent_fields_t; + + +@@ -16204,7 +16204,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_capabilities_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_open_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16234,7 +16234,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_close_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16264,7 +16264,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16294,7 +16294,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16324,7 +16324,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_open_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16354,7 +16354,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_close_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16384,7 +16384,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_period_unretain( + */ + sl_status_t uic_mqtt_dotdot_barrier_control_barrier_position_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16450,26 +16450,26 @@ void uic_mqtt_dotdot_barrier_control_publish_empty_supported_commands( + + typedef struct { + int16_t max_pressure; +- int16_t max_speed; +- int16_t max_flow; ++ uint16_t max_speed; ++ uint16_t max_flow; + int16_t min_const_pressure; + int16_t max_const_pressure; + int16_t min_comp_pressure; + int16_t max_comp_pressure; +- int16_t min_const_speed; +- int16_t max_const_speed; +- int16_t min_const_flow; +- int16_t max_const_flow; ++ uint16_t min_const_speed; ++ uint16_t max_const_speed; ++ uint16_t min_const_flow; ++ uint16_t max_const_flow; + int16_t min_const_temp; + int16_t max_const_temp; + uint16_t pump_status; + uint8_t effective_operation_mode; + uint8_t effective_control_mode; + int16_t capacity; +- int16_t speed; +- int32_t lifetime_running_hours; +- int32_t power; +- int32_t lifetime_energy_consumed; ++ uint16_t speed; ++ uint32_t lifetime_running_hours; ++ uint32_t power; ++ uint32_t lifetime_energy_consumed; + uint8_t operation_mode; + uint8_t control_mode; + uint16_t alarm_mask; +@@ -16611,7 +16611,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_pressure_unretain + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16641,7 +16641,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16791,7 +16791,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_comp_pressure_unr + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16821,7 +16821,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_unret + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16851,7 +16851,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_unret + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -16881,7 +16881,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_unreta + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17091,7 +17091,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_capacity_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17121,7 +17121,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17151,7 +17151,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hour + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17181,7 +17181,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_unretain( + */ + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -17375,17 +17375,17 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_get_relay_status_log_response_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t time_of_day, ++ uint16_t time_of_day, + + uint8_t relay_status, + + int16_t local_temperature, + +- int8_t humidity_percentage, ++ uint8_t humidity_percentage, + + int16_t set_point, + +- int16_t unread_entries ++ uint16_t unread_entries + + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_get_weekly_schedule_callback_t)( +@@ -17416,8 +17416,8 @@ typedef struct { + int16_t abs_max_heat_setpoint_limit; + int16_t abs_min_cool_setpoint_limit; + int16_t abs_max_cool_setpoint_limit; +- int8_t pi_cooling_demand; +- int8_t pi_heating_demand; ++ uint8_t pi_cooling_demand; ++ uint8_t pi_heating_demand; + uint8_t hvac_system_type_configuration; + int8_t local_temperature_calibration; + int16_t occupied_cooling_setpoint; +@@ -17435,24 +17435,24 @@ typedef struct { + uint8_t alarm_mask; + uint8_t thermostat_running_mode; + uint8_t start_of_week; +- int8_t number_of_weekly_transitions; +- int8_t number_of_daily_transitions; ++ uint8_t number_of_weekly_transitions; ++ uint8_t number_of_daily_transitions; + uint8_t temperature_setpoint_hold; +- int16_t temperature_setpoint_hold_duration; ++ uint16_t temperature_setpoint_hold_duration; + uint8_t thermostat_programming_operation_mode; + uint16_t thermostat_running_state; + uint8_t setpoint_change_source; + int16_t setpoint_change_amount; +- uint8_t setpoint_change_source_timestamp; +- int8_t occupied_setback; +- int8_t occupied_setback_min; +- int8_t occupied_setback_max; +- int8_t unoccupied_setback; +- int8_t unoccupied_setback_min; +- int8_t unoccupied_setback_max; +- int8_t emergency_heat_delta; ++ uint32_t setpoint_change_source_timestamp; ++ uint8_t occupied_setback; ++ uint8_t occupied_setback_min; ++ uint8_t occupied_setback_max; ++ uint8_t unoccupied_setback; ++ uint8_t unoccupied_setback_min; ++ uint8_t unoccupied_setback_max; ++ uint8_t emergency_heat_delta; + uint8_t ac_type; +- int16_t ac_capacity; ++ uint16_t ac_capacity; + uint8_t ac_refrigerant_type; + uint8_t ac_compressor_type; + uint32_t ac_error_code; +@@ -17571,17 +17571,17 @@ typedef struct { + * @brief Command fields for Thermostat/GetRelayStatusLogResponse + */ + typedef struct { +- int16_t time_of_day; ++ uint16_t time_of_day; + + uint8_t relay_status; + + int16_t local_temperature; + +- int8_t humidity_percentage; ++ uint8_t humidity_percentage; + + int16_t set_point; + +- int16_t unread_entries; ++ uint16_t unread_entries; + } uic_mqtt_dotdot_thermostat_command_get_relay_status_log_response_fields_t; + + /** +@@ -18146,7 +18146,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_abs_max_cool_setpoint_limit_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18176,7 +18176,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18716,7 +18716,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_start_of_week_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18746,7 +18746,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18806,7 +18806,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18956,7 +18956,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_amount_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -18986,7 +18986,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_unretain + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19016,7 +19016,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19046,7 +19046,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19076,7 +19076,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19106,7 +19106,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19136,7 +19136,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19166,7 +19166,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19226,7 +19226,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_ac_type_unretain( + */ + sl_status_t uic_mqtt_dotdot_thermostat_ac_capacity_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19654,13 +19654,13 @@ void uic_mqtt_dotdot_fan_control_publish_empty_supported_commands( + // Callback types used by the dehumidification_control cluster + + typedef struct { +- int8_t relative_humidity; +- int8_t dehumidification_cooling; +- int8_t rh_dehumidification_setpoint; ++ uint8_t relative_humidity; ++ uint8_t dehumidification_cooling; ++ uint8_t rh_dehumidification_setpoint; + uint8_t relative_humidity_mode; + uint8_t dehumidification_lockout; +- int8_t dehumidification_hysteresis; +- int8_t dehumidification_max_cool; ++ uint8_t dehumidification_hysteresis; ++ uint8_t dehumidification_max_cool; + uint8_t relative_humidity_display; + } uic_mqtt_dotdot_dehumidification_control_state_t; + +@@ -19754,7 +19754,7 @@ void uic_mqtt_dotdot_clear_dehumidification_control_force_read_attributes_callba + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19784,7 +19784,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_unretain( + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19814,7 +19814,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_un + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19904,7 +19904,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_lockout_un + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -19934,7 +19934,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis + */ + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -20246,11 +20246,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t hue, ++ uint8_t hue, + + CCDirection direction, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20263,7 +20263,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_hue_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -20276,9 +20276,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_hue_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int8_t transition_time, ++ uint8_t transition_time, + + uint8_t options_mask, + +@@ -20289,9 +20289,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_saturation_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20304,7 +20304,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_saturation_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -20317,9 +20317,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_saturation_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int8_t transition_time, ++ uint8_t transition_time, + + uint8_t options_mask, + +@@ -20330,11 +20330,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t hue, ++ uint8_t hue, + +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20345,11 +20345,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_color_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t colorx, ++ uint16_t colorx, + +- int16_t colory, ++ uint16_t colory, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20377,7 +20377,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_callback_t)( + + int16_t stepy, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20388,9 +20388,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_to_color_temperature_ca + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t color_temperature_mireds, ++ uint16_t color_temperature_mireds, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20401,11 +20401,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t enhanced_hue, ++ uint16_t enhanced_hue, + + CCDirection direction, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20418,7 +20418,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_hue_callback_t + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- int16_t rate, ++ uint16_t rate, + + uint8_t options_mask, + +@@ -20431,9 +20431,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_step_hue_callback_t + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- int16_t step_size, ++ uint16_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20444,11 +20444,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_sat + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t enhanced_hue, ++ uint16_t enhanced_hue, + +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -20465,9 +20465,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_color_loop_set_callback_t)( + + CCColorLoopDirection direction, + +- int16_t time, ++ uint16_t time, + +- int16_t start_hue, ++ uint16_t start_hue, + + uint8_t options_mask, + +@@ -20489,11 +20489,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_move_color_temperature_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + CCMoveMode move_mode, + +- int16_t rate, ++ uint16_t rate, + +- uint8_t * color_temperature_minimum_mireds, ++ uint16_t color_temperature_minimum_mireds, + +- uint8_t * color_temperature_maximum_mireds, ++ uint16_t color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -20506,13 +20506,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_temperature_callb + uic_mqtt_dotdot_callback_call_type_t call_type, + CCStepMode step_mode, + +- int16_t step_size, ++ uint16_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * color_temperature_minimum_mireds, ++ uint16_t color_temperature_minimum_mireds, + +- uint8_t * color_temperature_maximum_mireds, ++ uint16_t color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -20521,58 +20521,58 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_step_color_temperature_callb + ); + + typedef struct { +- int8_t current_hue; +- int8_t current_saturation; +- int16_t remaining_time; +- int16_t currentx; +- int16_t currenty; ++ uint8_t current_hue; ++ uint8_t current_saturation; ++ uint16_t remaining_time; ++ uint16_t currentx; ++ uint16_t currenty; + uint8_t drift_compensation; + const char* compensation_text; +- int16_t color_temperature_mireds; ++ uint16_t color_temperature_mireds; + uint8_t color_mode; + uint8_t options; +- int8_t number_of_primaries; +- int16_t primary1x; +- int16_t primary1y; +- int8_t primary1_intensity; +- int16_t primary2x; +- int16_t primary2y; +- int8_t primary2_intensity; +- int16_t primary3x; +- int16_t primary3y; +- int8_t primary3_intensity; +- int16_t primary4x; +- int16_t primary4y; +- int8_t primary4_intensity; +- int16_t primary5x; +- int16_t primary5y; +- int8_t primary5_intensity; +- int16_t primary6x; +- int16_t primary6y; +- int8_t primary6_intensity; +- int16_t white_pointx; +- int16_t white_pointy; +- int16_t color_pointrx; +- int16_t color_pointry; +- int8_t color_pointr_intensity; +- int16_t color_pointgx; +- int16_t color_pointgy; +- int8_t color_pointg_intensity; +- int16_t color_pointbx; +- int16_t color_pointby; +- int8_t color_pointb_intensity; +- int16_t enhanced_current_hue; ++ uint8_t number_of_primaries; ++ uint16_t primary1x; ++ uint16_t primary1y; ++ uint8_t primary1_intensity; ++ uint16_t primary2x; ++ uint16_t primary2y; ++ uint8_t primary2_intensity; ++ uint16_t primary3x; ++ uint16_t primary3y; ++ uint8_t primary3_intensity; ++ uint16_t primary4x; ++ uint16_t primary4y; ++ uint8_t primary4_intensity; ++ uint16_t primary5x; ++ uint16_t primary5y; ++ uint8_t primary5_intensity; ++ uint16_t primary6x; ++ uint16_t primary6y; ++ uint8_t primary6_intensity; ++ uint16_t white_pointx; ++ uint16_t white_pointy; ++ uint16_t color_pointrx; ++ uint16_t color_pointry; ++ uint8_t color_pointr_intensity; ++ uint16_t color_pointgx; ++ uint16_t color_pointgy; ++ uint8_t color_pointg_intensity; ++ uint16_t color_pointbx; ++ uint16_t color_pointby; ++ uint8_t color_pointb_intensity; ++ uint16_t enhanced_current_hue; + uint8_t enhanced_color_mode; +- int8_t color_loop_active; +- int8_t color_loop_direction; +- int16_t color_loop_time; +- int16_t color_loop_start_enhanced_hue; +- int16_t color_loop_stored_enhanced_hue; ++ uint8_t color_loop_active; ++ uint8_t color_loop_direction; ++ uint16_t color_loop_time; ++ uint16_t color_loop_start_enhanced_hue; ++ uint16_t color_loop_stored_enhanced_hue; + uint16_t color_capabilities; +- int16_t color_temp_physical_min_mireds; +- int16_t color_temp_physical_max_mireds; +- int16_t couple_color_temp_to_level_min_mireds; +- int16_t start_up_color_temperature_mireds; ++ uint16_t color_temp_physical_min_mireds; ++ uint16_t color_temp_physical_max_mireds; ++ uint16_t couple_color_temp_to_level_min_mireds; ++ uint16_t start_up_color_temperature_mireds; + } uic_mqtt_dotdot_color_control_state_t; + + typedef struct { +@@ -20650,11 +20650,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_force_read_attributes_callba + * @brief Command fields for ColorControl/MoveToHue + */ + typedef struct { +- int8_t hue; ++ uint8_t hue; + + CCDirection direction; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20667,7 +20667,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- int8_t rate; ++ uint8_t rate; + + uint8_t options_mask; + +@@ -20680,9 +20680,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- int8_t step_size; ++ uint8_t step_size; + +- int8_t transition_time; ++ uint8_t transition_time; + + uint8_t options_mask; + +@@ -20693,9 +20693,9 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToSaturation + */ + typedef struct { +- int8_t saturation; ++ uint8_t saturation; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20708,7 +20708,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- int8_t rate; ++ uint8_t rate; + + uint8_t options_mask; + +@@ -20721,9 +20721,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- int8_t step_size; ++ uint8_t step_size; + +- int8_t transition_time; ++ uint8_t transition_time; + + uint8_t options_mask; + +@@ -20734,11 +20734,11 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToHueAndSaturation + */ + typedef struct { +- int8_t hue; ++ uint8_t hue; + +- int8_t saturation; ++ uint8_t saturation; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20749,11 +20749,11 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToColor + */ + typedef struct { +- int16_t colorx; ++ uint16_t colorx; + +- int16_t colory; ++ uint16_t colory; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20781,7 +20781,7 @@ typedef struct { + + int16_t stepy; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20792,9 +20792,9 @@ typedef struct { + * @brief Command fields for ColorControl/MoveToColorTemperature + */ + typedef struct { +- int16_t color_temperature_mireds; ++ uint16_t color_temperature_mireds; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20805,11 +20805,11 @@ typedef struct { + * @brief Command fields for ColorControl/EnhancedMoveToHue + */ + typedef struct { +- int16_t enhanced_hue; ++ uint16_t enhanced_hue; + + CCDirection direction; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20822,7 +20822,7 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- int16_t rate; ++ uint16_t rate; + + uint8_t options_mask; + +@@ -20835,9 +20835,9 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- int16_t step_size; ++ uint16_t step_size; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20848,11 +20848,11 @@ typedef struct { + * @brief Command fields for ColorControl/EnhancedMoveToHueAndSaturation + */ + typedef struct { +- int16_t enhanced_hue; ++ uint16_t enhanced_hue; + +- int8_t saturation; ++ uint8_t saturation; + +- int16_t transition_time; ++ uint16_t transition_time; + + uint8_t options_mask; + +@@ -20869,9 +20869,9 @@ typedef struct { + + CCColorLoopDirection direction; + +- int16_t time; ++ uint16_t time; + +- int16_t start_hue; ++ uint16_t start_hue; + + uint8_t options_mask; + +@@ -20893,11 +20893,11 @@ typedef struct { + typedef struct { + CCMoveMode move_mode; + +- int16_t rate; ++ uint16_t rate; + +- uint8_t * color_temperature_minimum_mireds; ++ uint16_t color_temperature_minimum_mireds; + +- uint8_t * color_temperature_maximum_mireds; ++ uint16_t color_temperature_maximum_mireds; + + uint8_t options_mask; + +@@ -20910,13 +20910,13 @@ typedef struct { + typedef struct { + CCStepMode step_mode; + +- int16_t step_size; ++ uint16_t step_size; + +- int16_t transition_time; ++ uint16_t transition_time; + +- uint8_t * color_temperature_minimum_mireds; ++ uint16_t color_temperature_minimum_mireds; + +- uint8_t * color_temperature_maximum_mireds; ++ uint16_t color_temperature_maximum_mireds; + + uint8_t options_mask; + +@@ -21746,7 +21746,7 @@ void uic_mqtt_dotdot_clear_color_control_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_color_control_current_hue_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21776,7 +21776,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_hue_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_current_saturation_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21806,7 +21806,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_saturation_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_remaining_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21836,7 +21836,7 @@ sl_status_t uic_mqtt_dotdot_color_control_remaining_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_currentx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21866,7 +21866,7 @@ sl_status_t uic_mqtt_dotdot_color_control_currentx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_currenty_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -21956,7 +21956,7 @@ sl_status_t uic_mqtt_dotdot_color_control_compensation_text_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22046,7 +22046,7 @@ sl_status_t uic_mqtt_dotdot_color_control_options_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22076,7 +22076,7 @@ sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22106,7 +22106,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22136,7 +22136,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22166,7 +22166,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22196,7 +22196,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22226,7 +22226,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22256,7 +22256,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22286,7 +22286,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22316,7 +22316,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22346,7 +22346,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22376,7 +22376,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22406,7 +22406,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22436,7 +22436,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22466,7 +22466,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22496,7 +22496,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22526,7 +22526,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22556,7 +22556,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6x_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22586,7 +22586,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6y_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22616,7 +22616,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_white_pointx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22646,7 +22646,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_white_pointy_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22676,7 +22676,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointy_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22706,7 +22706,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22736,7 +22736,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointry_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22766,7 +22766,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22796,7 +22796,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22826,7 +22826,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22856,7 +22856,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22886,7 +22886,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointby_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22916,7 +22916,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointby_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -22946,7 +22946,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23006,7 +23006,7 @@ sl_status_t uic_mqtt_dotdot_color_control_enhanced_color_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23036,7 +23036,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23066,7 +23066,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23096,7 +23096,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23126,7 +23126,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_unretain + */ + sl_status_t uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23186,7 +23186,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_capabilities_unretain( + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23216,7 +23216,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_unretai + */ + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23246,7 +23246,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_unretai + */ + sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23276,7 +23276,7 @@ sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_ + */ + sl_status_t uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23341,22 +23341,22 @@ void uic_mqtt_dotdot_color_control_publish_empty_supported_commands( + // Callback types used by the ballast_configuration cluster + + typedef struct { +- int8_t physical_min_level; +- int8_t physical_max_level; ++ uint8_t physical_min_level; ++ uint8_t physical_max_level; + uint8_t ballast_status; +- int8_t min_level; +- int8_t max_level; +- int8_t power_on_level; +- int16_t power_on_fade_time; +- int8_t intrinsic_ballast_factor; +- int8_t ballast_factor_adjustment; +- int8_t lamp_quantity; ++ uint8_t min_level; ++ uint8_t max_level; ++ uint8_t power_on_level; ++ uint16_t power_on_fade_time; ++ uint8_t intrinsic_ballast_factor; ++ uint8_t ballast_factor_adjustment; ++ uint8_t lamp_quantity; + const char* lamp_type; + const char* lamp_manufacturer; +- int32_t lamp_rated_hours; +- int32_t lamp_burn_hours; ++ uint32_t lamp_rated_hours; ++ uint32_t lamp_burn_hours; + uint8_t lamp_alarm_mode; +- int32_t lamp_burn_hours_trip_point; ++ uint32_t lamp_burn_hours_trip_point; + } uic_mqtt_dotdot_ballast_configuration_state_t; + + typedef struct { +@@ -23457,7 +23457,7 @@ void uic_mqtt_dotdot_clear_ballast_configuration_force_read_attributes_callbacks + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23487,7 +23487,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23547,7 +23547,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23577,7 +23577,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23607,7 +23607,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23637,7 +23637,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23667,7 +23667,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23697,7 +23697,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_unret + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23727,7 +23727,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_unre + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23817,7 +23817,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_manufacturer_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23847,7 +23847,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23907,7 +23907,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_alarm_mode_unretain( + */ + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -23972,10 +23972,10 @@ void uic_mqtt_dotdot_ballast_configuration_publish_empty_supported_commands( + // Callback types used by the illuminance_measurement cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + uint8_t light_sensor_type; + } uic_mqtt_dotdot_illuminance_measurement_state_t; + +@@ -24066,7 +24066,7 @@ void uic_mqtt_dotdot_clear_illuminance_measurement_force_read_attributes_callbac + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24096,7 +24096,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24126,7 +24126,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24156,7 +24156,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24253,7 +24253,7 @@ void uic_mqtt_dotdot_illuminance_measurement_publish_empty_supported_commands( + typedef struct { + uint8_t level_status; + uint8_t light_sensor_type; +- int16_t illuminance_target_level; ++ uint16_t illuminance_target_level; + } uic_mqtt_dotdot_illuminance_level_sensing_state_t; + + typedef struct { +@@ -24401,7 +24401,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_light_sensor_type_unretain + */ + sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24469,7 +24469,7 @@ typedef struct { + int16_t measured_value; + int16_t min_measured_value; + int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t tolerance; + } uic_mqtt_dotdot_temperature_measurement_state_t; + + typedef struct { +@@ -24648,7 +24648,7 @@ sl_status_t uic_mqtt_dotdot_temperature_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -24716,11 +24716,11 @@ typedef struct { + int16_t measured_value; + int16_t min_measured_value; + int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t tolerance; + int16_t scaled_value; + int16_t min_scaled_value; + int16_t max_scaled_value; +- int16_t scaled_tolerance; ++ uint16_t scaled_tolerance; + int8_t scale; + } uic_mqtt_dotdot_pressure_measurement_state_t; + +@@ -24905,7 +24905,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25025,7 +25025,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_scaled_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25120,10 +25120,10 @@ void uic_mqtt_dotdot_pressure_measurement_publish_empty_supported_commands( + // Callback types used by the flow_measurement cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_flow_measurement_state_t; + + typedef struct { +@@ -25212,7 +25212,7 @@ void uic_mqtt_dotdot_clear_flow_measurement_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25242,7 +25242,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25272,7 +25272,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25302,7 +25302,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_flow_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25367,10 +25367,10 @@ void uic_mqtt_dotdot_flow_measurement_publish_empty_supported_commands( + // Callback types used by the relativity_humidity cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_relativity_humidity_state_t; + + typedef struct { +@@ -25459,7 +25459,7 @@ void uic_mqtt_dotdot_clear_relativity_humidity_force_read_attributes_callbacks() + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25489,7 +25489,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25519,7 +25519,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25549,7 +25549,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25617,15 +25617,15 @@ typedef struct { + uint8_t occupancy; + uint8_t occupancy_sensor_type; + uint8_t occupancy_sensor_type_bitmap; +- int16_t pir_occupied_to_unoccupied_delay; +- int16_t pir_unoccupied_to_occupied_delay; +- int8_t pir_unoccupied_to_occupied_threshold; +- int16_t ultrasonic_occupied_to_unoccupied_delay; +- int16_t ultrasonic_unoccupied_to_occupied_delay; +- int8_t ultrasonic_unoccupied_to_occupied_threshold; +- int16_t physical_contact_occupied_to_unoccupied_delay; +- int16_t physical_contact_unoccupied_to_occupied_delay; +- int8_t physical_contact_unoccupied_to_occupied_threshold; ++ uint16_t pir_occupied_to_unoccupied_delay; ++ uint16_t pir_unoccupied_to_occupied_delay; ++ uint8_t pir_unoccupied_to_occupied_threshold; ++ uint16_t ultrasonic_occupied_to_unoccupied_delay; ++ uint16_t ultrasonic_unoccupied_to_occupied_delay; ++ uint8_t ultrasonic_unoccupied_to_occupied_threshold; ++ uint16_t physical_contact_occupied_to_unoccupied_delay; ++ uint16_t physical_contact_unoccupied_to_occupied_delay; ++ uint8_t physical_contact_unoccupied_to_occupied_threshold; + } uic_mqtt_dotdot_occupancy_sensing_state_t; + + typedef struct { +@@ -25812,7 +25812,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_occupancy_sensor_type_bitmap_unret + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25842,7 +25842,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_u + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25872,7 +25872,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_u + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25902,7 +25902,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_thresho + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25932,7 +25932,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25962,7 +25962,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -25992,7 +25992,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26022,7 +26022,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unocc + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26052,7 +26052,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occ + */ + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26117,10 +26117,10 @@ void uic_mqtt_dotdot_occupancy_sensing_publish_empty_supported_commands( + // Callback types used by the soil_moisture cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_soil_moisture_state_t; + + typedef struct { +@@ -26209,7 +26209,7 @@ void uic_mqtt_dotdot_clear_soil_moisture_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26239,7 +26239,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26269,7 +26269,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26299,7 +26299,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_soil_moisture_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26364,10 +26364,10 @@ void uic_mqtt_dotdot_soil_moisture_publish_empty_supported_commands( + // Callback types used by the ph_measurement cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_ph_measurement_state_t; + + typedef struct { +@@ -26456,7 +26456,7 @@ void uic_mqtt_dotdot_clear_ph_measurement_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26486,7 +26486,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26516,7 +26516,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26546,7 +26546,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_ph_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26611,10 +26611,10 @@ void uic_mqtt_dotdot_ph_measurement_publish_empty_supported_commands( + // Callback types used by the electrical_conductivity_measurement cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_electrical_conductivity_measurement_state_t; + + typedef struct { +@@ -26703,7 +26703,7 @@ void uic_mqtt_dotdot_clear_electrical_conductivity_measurement_force_read_attrib + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26733,7 +26733,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_u + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26763,7 +26763,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_val + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26793,7 +26793,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_val + */ + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26858,10 +26858,10 @@ void uic_mqtt_dotdot_electrical_conductivity_measurement_publish_empty_supported + // Callback types used by the wind_speed_measurement cluster + + typedef struct { +- int16_t measured_value; +- int16_t min_measured_value; +- int16_t max_measured_value; +- int16_t tolerance; ++ uint16_t measured_value; ++ uint16_t min_measured_value; ++ uint16_t max_measured_value; ++ uint16_t tolerance; + } uic_mqtt_dotdot_wind_speed_measurement_state_t; + + typedef struct { +@@ -26950,7 +26950,7 @@ void uic_mqtt_dotdot_clear_wind_speed_measurement_force_read_attributes_callback + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -26980,7 +26980,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27010,7 +27010,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27040,7 +27040,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_unretain( + */ + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -27850,7 +27850,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + ZoneEnrollResponseEnrollResponseCode enroll_response_code, + +- int8_t zoneid ++ uint8_t zoneid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback_t)( +@@ -27861,9 +27861,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_status_change_notification_c + + uint8_t extended_status, + +- int8_t zoneid, ++ uint8_t zoneid, + +- int16_t delay ++ uint16_t delay + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_initiate_normal_operation_mode_callback_t)( +@@ -27877,16 +27877,16 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + IasZoneType zone_type, + +- int16_t manufacturer_code ++ uint16_t manufacturer_code + + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t test_mode_duration, ++ uint8_t test_mode_duration, + +- int8_t current_zone_sensitivity_level ++ uint8_t current_zone_sensitivity_level + + ); + +@@ -27895,9 +27895,9 @@ typedef struct { + uint8_t zone_type; + uint16_t zone_status; + uint64_t iascie_address; +- int8_t zoneid; +- int8_t number_of_zone_sensitivity_levels_supported; +- int8_t current_zone_sensitivity_level; ++ uint8_t zoneid; ++ uint8_t number_of_zone_sensitivity_levels_supported; ++ uint8_t current_zone_sensitivity_level; + } uic_mqtt_dotdot_ias_zone_state_t; + + typedef struct { +@@ -27932,7 +27932,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_force_read_attributes_callback_t) + typedef struct { + ZoneEnrollResponseEnrollResponseCode enroll_response_code; + +- int8_t zoneid; ++ uint8_t zoneid; + } uic_mqtt_dotdot_ias_zone_command_zone_enroll_response_fields_t; + + /** +@@ -27943,9 +27943,9 @@ typedef struct { + + uint8_t extended_status; + +- int8_t zoneid; ++ uint8_t zoneid; + +- int16_t delay; ++ uint16_t delay; + } uic_mqtt_dotdot_ias_zone_command_zone_status_change_notification_fields_t; + + /** +@@ -27954,16 +27954,16 @@ typedef struct { + typedef struct { + IasZoneType zone_type; + +- int16_t manufacturer_code; ++ uint16_t manufacturer_code; + } uic_mqtt_dotdot_ias_zone_command_zone_enroll_request_fields_t; + + /** + * @brief Command fields for IASZone/InitiateTestMode + */ + typedef struct { +- int8_t test_mode_duration; ++ uint8_t test_mode_duration; + +- int8_t current_zone_sensitivity_level; ++ uint8_t current_zone_sensitivity_level; + } uic_mqtt_dotdot_ias_zone_command_initiate_test_mode_fields_t; + + +@@ -28349,7 +28349,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_iascie_address_unretain( + */ + sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28379,7 +28379,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_unretain( + */ + sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28409,7 +28409,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported + */ + sl_status_t uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28478,9 +28478,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_start_warning_callback_t)( + uic_mqtt_dotdot_callback_call_type_t call_type, + uint8_t siren_configuration, + +- int16_t warning_duration, ++ uint16_t warning_duration, + +- int8_t strobe_duty_cycle, ++ uint8_t strobe_duty_cycle, + + IaswdLevel strobe_level + +@@ -28494,7 +28494,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_squawk_callback_t)( + ); + + typedef struct { +- int16_t max_duration; ++ uint16_t max_duration; + } uic_mqtt_dotdot_iaswd_state_t; + + typedef struct { +@@ -28523,9 +28523,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_force_read_attributes_callback_t)( + typedef struct { + uint8_t siren_configuration; + +- int16_t warning_duration; ++ uint16_t warning_duration; + +- int8_t strobe_duty_cycle; ++ uint8_t strobe_duty_cycle; + + IaswdLevel strobe_level; + } uic_mqtt_dotdot_iaswd_command_start_warning_fields_t; +@@ -28680,7 +28680,7 @@ void uic_mqtt_dotdot_clear_iaswd_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_iaswd_max_duration_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28745,23 +28745,23 @@ void uic_mqtt_dotdot_iaswd_publish_empty_supported_commands( + // Callback types used by the metering cluster + + typedef struct { +- int64_t current_summation_delivered; +- int64_t current_summation_received; +- int64_t current_max_demand_delivered; ++ uint64_t current_summation_delivered; ++ uint64_t current_summation_received; ++ uint64_t current_max_demand_delivered; + int8_t current_max_demand_received; + int8_t power_factor; +- uint8_t reading_snap_shot_time; +- uint8_t current_max_demand_delivered_time; +- uint8_t current_max_demand_received_time; +- int8_t default_update_period; ++ uint32_t reading_snap_shot_time; ++ uint32_t current_max_demand_delivered_time; ++ uint32_t current_max_demand_received_time; ++ uint8_t default_update_period; + uint8_t supply_status; +- int64_t current_inlet_energy_carrier_summation; +- int64_t current_outlet_energy_carrier_summation; ++ uint64_t current_inlet_energy_carrier_summation; ++ uint64_t current_outlet_energy_carrier_summation; + int32_t inlet_temperature; + int32_t outlet_temperature; + uint8_t unitof_measure; +- int32_t multiplier; +- int32_t divisor; ++ uint32_t multiplier; ++ uint32_t divisor; + uint8_t summation_formatting; + uint8_t demand_formatting; + uint8_t historical_consumption_formatting; +@@ -28881,7 +28881,7 @@ void uic_mqtt_dotdot_clear_metering_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28911,7 +28911,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_summation_received_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -28941,7 +28941,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_received_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29031,7 +29031,7 @@ sl_status_t uic_mqtt_dotdot_metering_power_factor_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29061,7 +29061,7 @@ sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29091,7 +29091,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29121,7 +29121,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_default_update_period_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29181,7 +29181,7 @@ sl_status_t uic_mqtt_dotdot_metering_supply_status_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29211,7 +29211,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_unre + */ + sl_status_t uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29331,7 +29331,7 @@ sl_status_t uic_mqtt_dotdot_metering_unitof_measure_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_multiplier_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29361,7 +29361,7 @@ sl_status_t uic_mqtt_dotdot_metering_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_metering_divisor_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -29698,14 +29698,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_profile_info_re + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int8_t profile_count, ++ uint8_t profile_count, + + ProfileIntervalPeriod profile_interval_period, + +- int8_t max_number_of_intervals, ++ uint8_t max_number_of_intervals, + + uint8_t list_of_attributes_count, +- const uint8_t *list_of_attributes ++ const uint16_t *list_of_attributes + + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_profile_info_callback_t)( +@@ -29717,29 +29717,29 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_measurement_pro + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t start_time, ++ uint32_t start_time, + + GetMeasurementProfileResponseStatus status, + + ProfileIntervalPeriod profile_interval_period, + +- int8_t number_of_intervals_delivered, ++ uint8_t number_of_intervals_delivered, + +- uint8_t attribute_id, ++ uint16_t attribute_id, + + uint8_t intervals_count, +- const int8_t *intervals ++ const uint8_t *intervals + + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- uint8_t attributeid, ++ uint16_t attributeid, + +- uint8_t start_time, ++ uint32_t start_time, + +- int8_t number_of_intervals ++ uint8_t number_of_intervals + + ); + +@@ -29754,19 +29754,19 @@ typedef struct { + int16_t dc_power; + int16_t dc_power_min; + int16_t dc_power_max; +- int16_t dc_voltage_multiplier; +- int16_t dc_voltage_divisor; +- int16_t dc_current_multiplier; +- int16_t dc_current_divisor; +- int16_t dc_power_multiplier; +- int16_t dc_power_divisor; +- int16_t ac_frequency; +- int16_t ac_frequency_min; +- int16_t ac_frequency_max; +- int16_t neutral_current; ++ uint16_t dc_voltage_multiplier; ++ uint16_t dc_voltage_divisor; ++ uint16_t dc_current_multiplier; ++ uint16_t dc_current_divisor; ++ uint16_t dc_power_multiplier; ++ uint16_t dc_power_divisor; ++ uint16_t ac_frequency; ++ uint16_t ac_frequency_min; ++ uint16_t ac_frequency_max; ++ uint16_t neutral_current; + int32_t total_active_power; + int32_t total_reactive_power; +- int32_t total_apparent_power; ++ uint32_t total_apparent_power; + int16_t measured1st_harmonic_current; + int16_t measured3rd_harmonic_current; + int16_t measured5th_harmonic_current; +@@ -29779,40 +29779,40 @@ typedef struct { + int16_t measured_phase7th_harmonic_current; + int16_t measured_phase9th_harmonic_current; + int16_t measured_phase11th_harmonic_current; +- int16_t ac_frequency_multiplier; +- int16_t ac_frequency_divisor; +- int32_t power_multiplier; +- int32_t power_divisor; ++ uint16_t ac_frequency_multiplier; ++ uint16_t ac_frequency_divisor; ++ uint32_t power_multiplier; ++ uint32_t power_divisor; + int8_t harmonic_current_multiplier; + int8_t phase_harmonic_current_multiplier; +- int16_t line_current; ++ uint16_t line_current; + int16_t active_current; + int16_t reactive_current; +- int16_t rms_voltage; +- int16_t rms_voltage_min; +- int16_t rms_voltage_max; +- int16_t rms_current; +- int16_t rms_current_min; +- int16_t rms_current_max; ++ uint16_t rms_voltage; ++ uint16_t rms_voltage_min; ++ uint16_t rms_voltage_max; ++ uint16_t rms_current; ++ uint16_t rms_current_min; ++ uint16_t rms_current_max; + int16_t active_power; + int16_t active_power_min; + int16_t active_power_max; + int16_t reactive_power; +- int16_t apparent_power; ++ uint16_t apparent_power; + int8_t power_factor; +- int16_t average_rms_voltage_measurement_period; +- int16_t average_rms_over_voltage_counter; +- int16_t average_rms_under_voltage_counter; +- int16_t rms_extreme_over_voltage_period; +- int16_t rms_extreme_under_voltage_period; +- int16_t rms_voltage_sag_period; +- int16_t rms_voltage_swell_period; +- int16_t ac_voltage_multiplier; +- int16_t ac_voltage_divisor; +- int16_t ac_current_multiplier; +- int16_t ac_current_divisor; +- int16_t ac_power_multiplier; +- int16_t ac_power_divisor; ++ uint16_t average_rms_voltage_measurement_period; ++ uint16_t average_rms_over_voltage_counter; ++ uint16_t average_rms_under_voltage_counter; ++ uint16_t rms_extreme_over_voltage_period; ++ uint16_t rms_extreme_under_voltage_period; ++ uint16_t rms_voltage_sag_period; ++ uint16_t rms_voltage_swell_period; ++ uint16_t ac_voltage_multiplier; ++ uint16_t ac_voltage_divisor; ++ uint16_t ac_current_multiplier; ++ uint16_t ac_current_divisor; ++ uint16_t ac_power_multiplier; ++ uint16_t ac_power_divisor; + uint8_t dc_overload_alarms_mask; + int16_t dc_voltage_overload; + int16_t dc_current_overload; +@@ -29827,50 +29827,50 @@ typedef struct { + int16_t rms_extreme_under_voltage; + int16_t rms_voltage_sag; + int16_t rms_voltage_swell; +- int16_t line_current_phb; ++ uint16_t line_current_phb; + int16_t active_current_phb; + int16_t reactive_current_phb; +- int16_t rms_voltage_phb; +- int16_t rms_voltage_min_phb; +- int16_t rms_voltage_max_phb; +- int16_t rms_current_phb; +- int16_t rms_current_min_phb; +- int16_t rms_current_max_phb; ++ uint16_t rms_voltage_phb; ++ uint16_t rms_voltage_min_phb; ++ uint16_t rms_voltage_max_phb; ++ uint16_t rms_current_phb; ++ uint16_t rms_current_min_phb; ++ uint16_t rms_current_max_phb; + int16_t active_power_phb; + int16_t active_power_min_phb; + int16_t active_power_max_phb; + int16_t reactive_power_phb; +- int16_t apparent_power_phb; ++ uint16_t apparent_power_phb; + int8_t power_factor_phb; +- int16_t average_rms_voltage_measurement_period_phb; +- int16_t average_rms_over_voltage_counter_phb; +- int16_t average_rms_under_voltage_counter_phb; +- int16_t rms_extreme_over_voltage_period_phb; +- int16_t rms_extreme_under_voltage_period_phb; +- int16_t rms_voltage_sag_period_phb; +- int16_t rms_voltage_swell_period_phb; +- int16_t line_current_phc; ++ uint16_t average_rms_voltage_measurement_period_phb; ++ uint16_t average_rms_over_voltage_counter_phb; ++ uint16_t average_rms_under_voltage_counter_phb; ++ uint16_t rms_extreme_over_voltage_period_phb; ++ uint16_t rms_extreme_under_voltage_period_phb; ++ uint16_t rms_voltage_sag_period_phb; ++ uint16_t rms_voltage_swell_period_phb; ++ uint16_t line_current_phc; + int16_t active_current_phc; + int16_t reactive_current_phc; +- int16_t rms_voltage_phc; +- int16_t rms_voltage_min_phc; +- int16_t rms_voltage_max_phc; +- int16_t rms_current_phc; +- int16_t rms_current_min_phc; +- int16_t rms_current_max_phc; ++ uint16_t rms_voltage_phc; ++ uint16_t rms_voltage_min_phc; ++ uint16_t rms_voltage_max_phc; ++ uint16_t rms_current_phc; ++ uint16_t rms_current_min_phc; ++ uint16_t rms_current_max_phc; + int16_t active_power_phc; + int16_t active_power_min_phc; + int16_t active_power_max_phc; + int16_t reactive_power_phc; +- int16_t apparent_power_phc; ++ uint16_t apparent_power_phc; + int8_t power_factor_phc; +- int16_t average_rms_voltage_measurement_period_phc; +- int16_t average_rms_over_voltage_counter_phc; +- int16_t average_rms_under_voltage_counter_phc; +- int16_t rms_extreme_over_voltage_period_phc; +- int16_t rms_extreme_under_voltage_period_phc; +- int16_t rms_voltage_sag_period_phc; +- int16_t rms_voltage_swell_period_phc; ++ uint16_t average_rms_voltage_measurement_period_phc; ++ uint16_t average_rms_over_voltage_counter_phc; ++ uint16_t average_rms_under_voltage_counter_phc; ++ uint16_t rms_extreme_over_voltage_period_phc; ++ uint16_t rms_extreme_under_voltage_period_phc; ++ uint16_t rms_voltage_sag_period_phc; ++ uint16_t rms_voltage_swell_period_phc; + } uic_mqtt_dotdot_electrical_measurement_state_t; + + typedef struct { +@@ -30023,43 +30023,43 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_force_read_attribut + * @brief Command fields for ElectricalMeasurement/GetProfileInfoResponse + */ + typedef struct { +- int8_t profile_count; ++ uint8_t profile_count; + + ProfileIntervalPeriod profile_interval_period; + +- int8_t max_number_of_intervals; ++ uint8_t max_number_of_intervals; + + uint8_t list_of_attributes_count; +- const uint8_t *list_of_attributes; ++ const uint16_t *list_of_attributes; + } uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t; + + /** + * @brief Command fields for ElectricalMeasurement/GetMeasurementProfileResponse + */ + typedef struct { +- uint8_t start_time; ++ uint32_t start_time; + + GetMeasurementProfileResponseStatus status; + + ProfileIntervalPeriod profile_interval_period; + +- int8_t number_of_intervals_delivered; ++ uint8_t number_of_intervals_delivered; + +- uint8_t attribute_id; ++ uint16_t attribute_id; + + uint8_t intervals_count; +- const int8_t *intervals; ++ const uint8_t *intervals; + } uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t; + + /** + * @brief Command fields for ElectricalMeasurement/GetMeasurementProfile + */ + typedef struct { +- uint8_t attributeid; ++ uint16_t attributeid; + +- uint8_t start_time; ++ uint32_t start_time; + +- int8_t number_of_intervals; ++ uint8_t number_of_intervals; + } uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_fields_t; + + +@@ -30585,7 +30585,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30615,7 +30615,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30645,7 +30645,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30675,7 +30675,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30705,7 +30705,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30735,7 +30735,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30765,7 +30765,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30795,7 +30795,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30825,7 +30825,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30855,7 +30855,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -30945,7 +30945,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_total_reactive_power_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31335,7 +31335,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_measured_phase11th_harmonic_c + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31365,7 +31365,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_unret + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31395,7 +31395,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31425,7 +31425,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31515,7 +31515,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_phase_harmonic_current_multip + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31605,7 +31605,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31635,7 +31635,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31665,7 +31665,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31695,7 +31695,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31725,7 +31725,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31755,7 +31755,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31905,7 +31905,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31965,7 +31965,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -31995,7 +31995,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32025,7 +32025,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32055,7 +32055,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32085,7 +32085,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32115,7 +32115,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32145,7 +32145,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_unreta + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32175,7 +32175,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_unre + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32205,7 +32205,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32235,7 +32235,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32265,7 +32265,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_unretai + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32295,7 +32295,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32325,7 +32325,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32775,7 +32775,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32865,7 +32865,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phb_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32895,7 +32895,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32925,7 +32925,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32955,7 +32955,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -32985,7 +32985,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33015,7 +33015,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33165,7 +33165,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33225,7 +33225,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phb_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33255,7 +33255,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33285,7 +33285,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33315,7 +33315,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33345,7 +33345,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33375,7 +33375,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33405,7 +33405,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_un + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33435,7 +33435,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_ + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33525,7 +33525,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phc_unretain + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33555,7 +33555,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33585,7 +33585,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33615,7 +33615,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33645,7 +33645,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33675,7 +33675,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33825,7 +33825,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33885,7 +33885,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phc_unretain( + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33915,7 +33915,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33945,7 +33945,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -33975,7 +33975,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34005,7 +34005,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34035,7 +34035,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34065,7 +34065,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_un + */ + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34130,37 +34130,37 @@ void uic_mqtt_dotdot_electrical_measurement_publish_empty_supported_commands( + // Callback types used by the diagnostics cluster + + typedef struct { +- int16_t number_of_resets; +- int16_t persistent_memory_writes; +- int32_t mac_rx_bcast; +- int32_t mac_tx_bcast; +- int32_t mac_rx_ucast; +- int32_t mac_tx_ucast; +- int16_t mac_tx_ucast_retry; +- int16_t mac_tx_ucast_fail; +- int16_t aps_rx_bcast; +- int16_t aps_tx_bcast; +- int16_t aps_rx_ucast; +- int16_t aps_tx_ucast_success; +- int16_t aps_tx_ucast_retry; +- int16_t aps_tx_ucast_fail; +- int16_t route_disc_initiated; +- int16_t neighbor_added; +- int16_t neighbor_removed; +- int16_t neighbor_stale; +- int16_t join_indication; +- int16_t child_moved; +- int16_t nwkfc_failure; +- int16_t apsfc_failure; +- int16_t aps_unauthorized_key; +- int16_t nwk_decrypt_failures; +- int16_t aps_decrypt_failures; +- int16_t packet_buffer_allocate_failures; +- int16_t relayed_ucast; +- int16_t phy_to_mac_queue_limit_reached; +- int16_t packet_validate_drop_count; +- int16_t average_mac_retry_per_aps_message_sent; +- int8_t last_messagelqi; ++ uint16_t number_of_resets; ++ uint16_t persistent_memory_writes; ++ uint32_t mac_rx_bcast; ++ uint32_t mac_tx_bcast; ++ uint32_t mac_rx_ucast; ++ uint32_t mac_tx_ucast; ++ uint16_t mac_tx_ucast_retry; ++ uint16_t mac_tx_ucast_fail; ++ uint16_t aps_rx_bcast; ++ uint16_t aps_tx_bcast; ++ uint16_t aps_rx_ucast; ++ uint16_t aps_tx_ucast_success; ++ uint16_t aps_tx_ucast_retry; ++ uint16_t aps_tx_ucast_fail; ++ uint16_t route_disc_initiated; ++ uint16_t neighbor_added; ++ uint16_t neighbor_removed; ++ uint16_t neighbor_stale; ++ uint16_t join_indication; ++ uint16_t child_moved; ++ uint16_t nwkfc_failure; ++ uint16_t apsfc_failure; ++ uint16_t aps_unauthorized_key; ++ uint16_t nwk_decrypt_failures; ++ uint16_t aps_decrypt_failures; ++ uint16_t packet_buffer_allocate_failures; ++ uint16_t relayed_ucast; ++ uint16_t phy_to_mac_queue_limit_reached; ++ uint16_t packet_validate_drop_count; ++ uint16_t average_mac_retry_per_aps_message_sent; ++ uint8_t last_messagelqi; + int8_t last_messagerssi; + } uic_mqtt_dotdot_diagnostics_state_t; + +@@ -34278,7 +34278,7 @@ void uic_mqtt_dotdot_clear_diagnostics_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34308,7 +34308,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34338,7 +34338,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34368,7 +34368,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34398,7 +34398,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34428,7 +34428,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34458,7 +34458,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34488,7 +34488,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34518,7 +34518,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34548,7 +34548,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34578,7 +34578,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34608,7 +34608,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34638,7 +34638,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34668,7 +34668,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34698,7 +34698,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34728,7 +34728,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34758,7 +34758,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34788,7 +34788,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34818,7 +34818,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34848,7 +34848,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34878,7 +34878,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34908,7 +34908,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34938,7 +34938,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34968,7 +34968,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -34998,7 +34998,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35028,7 +35028,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35058,7 +35058,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_unretain + */ + sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35088,7 +35088,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35118,7 +35118,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35148,7 +35148,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_unretain( + */ + sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35178,7 +35178,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_u + */ + sl_status_t uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -35281,13 +35281,13 @@ typedef sl_status_t (*uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report + + bool transmission_successful, + +- int16_t transmission_time_ms, ++ uint16_t transmission_time_ms, + + int8_t tx_powerd_bm, + +- int8_t tx_channel, ++ uint8_t tx_channel, + +- int8_t routing_attempts, ++ uint8_t routing_attempts, + + bool route_changed, + +@@ -35303,7 +35303,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report + + int8_t ackrssi, + +- int8_t ack_channel, ++ uint8_t ack_channel, + + const char* last_route_failed_link_functionalunid, + +@@ -35353,13 +35353,13 @@ typedef struct { + + bool transmission_successful; + +- int16_t transmission_time_ms; ++ uint16_t transmission_time_ms; + + int8_t tx_powerd_bm; + +- int8_t tx_channel; ++ uint8_t tx_channel; + +- int8_t routing_attempts; ++ uint8_t routing_attempts; + + bool route_changed; + +@@ -35375,7 +35375,7 @@ typedef struct { + + int8_t ackrssi; + +- int8_t ack_channel; ++ uint8_t ack_channel; + + const char* last_route_failed_link_functionalunid; + +@@ -35617,10 +35617,10 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_enable_nls_callback_t)( + + typedef struct { + size_t endpoint_id_list_count; +- const int8_t* endpoint_id_list; ++ const uint8_t* endpoint_id_list; + uint8_t network_status; + uint8_t security; +- int32_t maximum_command_delay; ++ uint32_t maximum_command_delay; + size_t network_list_count; + const char** network_list; + } uic_mqtt_dotdot_state_state_t; +@@ -35954,7 +35954,7 @@ void uic_mqtt_dotdot_clear_state_force_read_attributes_callbacks(); + sl_status_t uic_mqtt_dotdot_state_endpoint_id_list_publish( + const char *base_topic, + size_t value_count, +- const int8_t* value, ++ const uint8_t* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -36044,7 +36044,7 @@ sl_status_t uic_mqtt_dotdot_state_security_unretain( + */ + sl_status_t uic_mqtt_dotdot_state_maximum_command_delay_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -36147,7 +36147,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_binding_bind_callback_t)( + + const char* destination_unid, + +- int8_t destination_ep ++ uint8_t destination_ep + + ); + typedef sl_status_t (*uic_mqtt_dotdot_binding_unbind_callback_t)( +@@ -36158,7 +36158,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_binding_unbind_callback_t)( + + const char* destination_unid, + +- int8_t destination_ep ++ uint8_t destination_ep + + ); + typedef sl_status_t (*uic_mqtt_dotdot_binding_bind_to_protocol_controller_callback_t)( +@@ -36214,7 +36214,7 @@ typedef struct { + + const char* destination_unid; + +- int8_t destination_ep; ++ uint8_t destination_ep; + } uic_mqtt_dotdot_binding_command_bind_fields_t; + + /** +@@ -36225,7 +36225,7 @@ typedef struct { + + const char* destination_unid; + +- int8_t destination_ep; ++ uint8_t destination_ep; + } uic_mqtt_dotdot_binding_command_unbind_fields_t; + + /** +@@ -36594,7 +36594,7 @@ void uic_mqtt_dotdot_binding_publish_empty_supported_commands( + // Callback types used by the system_metrics cluster + + typedef struct { +- int32_t reporting_interval_seconds; ++ uint32_t reporting_interval_seconds; + size_t cpu_usage_percent_count; + const double* cpu_usage_percent; + size_t cpu_frequencym_hz_count; +@@ -36622,14 +36622,14 @@ typedef struct { + const WirelessNetworkInterfaceData* wireless_network_interfaces_data; + const char* hostname; + const char* fqdn; +- int64_t uptime_minutes; ++ uint64_t uptime_minutes; + double current_temperature_celcius; + double average_temperature_celcius; + double min_temperature_celcius; + double max_temperature_celcius; + bool power_plugged; + double battery_percentage; +- int64_t system_interrupts; ++ uint64_t system_interrupts; + } uic_mqtt_dotdot_system_metrics_state_t; + + typedef struct { +@@ -36741,7 +36741,7 @@ void uic_mqtt_dotdot_clear_system_metrics_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37329,7 +37329,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_fqdn_unretain( + */ + sl_status_t uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37539,7 +37539,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_battery_percentage_unretain( + */ + sl_status_t uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37622,20 +37622,20 @@ typedef struct { + bool application_connected; + size_t application_mqtt_topics_count; + const char** application_mqtt_topics; +- int64_t uptime_minutes; +- int64_t process_id; ++ uint64_t uptime_minutes; ++ uint64_t process_id; + const char* hostname; + const char* fqdn; + bool mqtt_logging_enabled; + uint8_t mqtt_logging_level; +- int32_t mqtt_statistics_reporting_interval_seconds; +- int64_t mqtt_messages_sent; +- int64_t mqtt_messages_received; +- int64_t mqtt_subscription_count; ++ uint32_t mqtt_statistics_reporting_interval_seconds; ++ uint64_t mqtt_messages_sent; ++ uint64_t mqtt_messages_received; ++ uint64_t mqtt_subscription_count; + double mqtt_average_delivery_time_seconds; + double mqtt_min_delivery_time_seconds; + double mqtt_max_delivery_time_seconds; +- int32_t application_statistics_reporting_interval_seconds; ++ uint32_t application_statistics_reporting_interval_seconds; + double application_cpu_usage_percent; + double application_cpu_average_usage_percent; + double application_cpu_min_usage_percent; +@@ -37923,7 +37923,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_application_mqtt_topics_unret + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -37953,7 +37953,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_process_id_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38103,7 +38103,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_logging_level_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38133,7 +38133,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_int + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38163,7 +38163,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_unretain( + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38193,7 +38193,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_unreta + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38313,7 +38313,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_max_delivery_time_second + */ + sl_status_t uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -38713,7 +38713,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_paramete + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t parameter_id ++ uint16_t parameter_id + + ); + typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_default_reset_all_parameters_callback_t)( +@@ -38725,7 +38725,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_set_parameter_cal + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t parameter_id, ++ uint16_t parameter_id, + + int64_t value + +@@ -38734,9 +38734,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_discover_paramete + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t first_parameter_id, ++ uint16_t first_parameter_id, + +- int16_t last_parameter_id ++ uint16_t last_parameter_id + + ); + +@@ -38769,14 +38769,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_configuration_parameters_force_read_attrib + * @brief Command fields for ConfigurationParameters/DiscoverParameter + */ + typedef struct { +- int16_t parameter_id; ++ uint16_t parameter_id; + } uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_fields_t; + + /** + * @brief Command fields for ConfigurationParameters/SetParameter + */ + typedef struct { +- int16_t parameter_id; ++ uint16_t parameter_id; + + int64_t value; + } uic_mqtt_dotdot_configuration_parameters_command_set_parameter_fields_t; +@@ -38785,9 +38785,9 @@ typedef struct { + * @brief Command fields for ConfigurationParameters/DiscoverParameterRange + */ + typedef struct { +- int16_t first_parameter_id; ++ uint16_t first_parameter_id; + +- int16_t last_parameter_id; ++ uint16_t last_parameter_id; + } uic_mqtt_dotdot_configuration_parameters_command_discover_parameter_range_fields_t; + + +@@ -39082,7 +39082,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_add_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + UserTypeEnum user_type, + +@@ -39092,7 +39092,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_add_user_callback_t)( + + const char* user_name, + +- int16_t expiring_timeout_minutes, ++ uint16_t expiring_timeout_minutes, + + UserNameEncodingType user_name_encoding + +@@ -39101,7 +39101,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_modify_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + UserTypeEnum user_type, + +@@ -39111,7 +39111,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_modify_user_callback_t)( + + const char* user_name, + +- int16_t expiring_timeout_minutes, ++ uint16_t expiring_timeout_minutes, + + UserNameEncodingType user_name_encoding + +@@ -39120,18 +39120,18 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_add_credential_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + + const char* credential_data + +@@ -39140,11 +39140,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_modify_credential_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + + const char* credential_data + +@@ -39153,11 +39153,11 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_credential_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot ++ uint16_t credential_slot + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_users_callback_t)( +@@ -39181,14 +39181,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_for + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type + +@@ -39197,26 +39197,26 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_start_add + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + +- int8_t credential_learn_timeout ++ uint8_t credential_learn_timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + +- int8_t credential_learn_timeout ++ uint8_t credential_learn_timeout + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t)( +@@ -39230,20 +39230,20 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_credential_association_cal + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type, + +- int16_t source_user_uniqueid, ++ uint16_t source_user_uniqueid, + +- int16_t source_credential_slot, ++ uint16_t source_credential_slot, + +- int16_t destination_user_uniqueid, ++ uint16_t destination_user_uniqueid, + +- int16_t destination_credential_slot ++ uint16_t destination_credential_slot + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t)( +@@ -39272,7 +39272,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_ + ); + + typedef struct { +- int16_t supported_user_unique_identifiers; ++ uint16_t supported_user_unique_identifiers; + uint8_t supported_credential_rules; + uint16_t supported_credential_types; + uint16_t supported_user_types; +@@ -39313,7 +39313,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_force_read_attributes_call + * @brief Command fields for UserCredential/AddUser + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + UserTypeEnum user_type; + +@@ -39323,7 +39323,7 @@ typedef struct { + + const char* user_name; + +- int16_t expiring_timeout_minutes; ++ uint16_t expiring_timeout_minutes; + + UserNameEncodingType user_name_encoding; + } uic_mqtt_dotdot_user_credential_command_add_user_fields_t; +@@ -39332,7 +39332,7 @@ typedef struct { + * @brief Command fields for UserCredential/ModifyUser + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + UserTypeEnum user_type; + +@@ -39342,7 +39342,7 @@ typedef struct { + + const char* user_name; + +- int16_t expiring_timeout_minutes; ++ uint16_t expiring_timeout_minutes; + + UserNameEncodingType user_name_encoding; + } uic_mqtt_dotdot_user_credential_command_modify_user_fields_t; +@@ -39351,18 +39351,18 @@ typedef struct { + * @brief Command fields for UserCredential/DeleteUser + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + } uic_mqtt_dotdot_user_credential_command_delete_user_fields_t; + + /** + * @brief Command fields for UserCredential/AddCredential + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + +- int16_t credential_slot; ++ uint16_t credential_slot; + + const char* credential_data; + } uic_mqtt_dotdot_user_credential_command_add_credential_fields_t; +@@ -39371,11 +39371,11 @@ typedef struct { + * @brief Command fields for UserCredential/ModifyCredential + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + +- int16_t credential_slot; ++ uint16_t credential_slot; + + const char* credential_data; + } uic_mqtt_dotdot_user_credential_command_modify_credential_fields_t; +@@ -39384,11 +39384,11 @@ typedef struct { + * @brief Command fields for UserCredential/DeleteCredential + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + +- int16_t credential_slot; ++ uint16_t credential_slot; + } uic_mqtt_dotdot_user_credential_command_delete_credential_fields_t; + + /** +@@ -39402,14 +39402,14 @@ typedef struct { + * @brief Command fields for UserCredential/DeleteAllCredentialsForUser + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + } uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_fields_t; + + /** + * @brief Command fields for UserCredential/DeleteAllCredentialsForUserByType + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + } uic_mqtt_dotdot_user_credential_command_delete_all_credentials_for_user_by_type_fields_t; +@@ -39418,26 +39418,26 @@ typedef struct { + * @brief Command fields for UserCredential/CredentialLearnStartAdd + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + +- int16_t credential_slot; ++ uint16_t credential_slot; + +- int8_t credential_learn_timeout; ++ uint8_t credential_learn_timeout; + } uic_mqtt_dotdot_user_credential_command_credential_learn_start_add_fields_t; + + /** + * @brief Command fields for UserCredential/CredentialLearnStartModify + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + + CredType credential_type; + +- int16_t credential_slot; ++ uint16_t credential_slot; + +- int8_t credential_learn_timeout; ++ uint8_t credential_learn_timeout; + } uic_mqtt_dotdot_user_credential_command_credential_learn_start_modify_fields_t; + + /** +@@ -39446,20 +39446,20 @@ typedef struct { + typedef struct { + CredType credential_type; + +- int16_t source_user_uniqueid; ++ uint16_t source_user_uniqueid; + +- int16_t source_credential_slot; ++ uint16_t source_credential_slot; + +- int16_t destination_user_uniqueid; ++ uint16_t destination_user_uniqueid; + +- int16_t destination_credential_slot; ++ uint16_t destination_credential_slot; + } uic_mqtt_dotdot_user_credential_command_credential_association_fields_t; + + /** + * @brief Command fields for UserCredential/GetUserChecksum + */ + typedef struct { +- int16_t user_uniqueid; ++ uint16_t user_uniqueid; + } uic_mqtt_dotdot_user_credential_command_get_user_checksum_fields_t; + + /** +@@ -40339,7 +40339,7 @@ void uic_mqtt_dotdot_clear_user_credential_force_read_attributes_callbacks(); + */ + sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -41504,9 +41504,9 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callba + uic_mqtt_dotdot_callback_call_type_t call_type, + SetpointType type, + +- int8_t precision, ++ uint8_t precision, + +- int8_t scale, ++ uint8_t scale, + + int32_t value + +@@ -41521,17 +41521,17 @@ typedef struct { + int32_t humidifier_setpoint_max; + int32_t humidifier_setpoint; + uint8_t humidifier_setpoint_scale; +- int8_t humidifier_setpoint_precision; ++ uint8_t humidifier_setpoint_precision; + int32_t dehumidifier_setpoint_min; + int32_t dehumidifier_setpoint_max; + int32_t dehumidifier_setpoint; + uint8_t dehumidifier_setpoint_scale; +- int8_t dehumidifier_setpoint_precision; ++ uint8_t dehumidifier_setpoint_precision; + int32_t auto_setpoint_min; + int32_t auto_setpoint_max; + int32_t auto_setpoint; + uint8_t auto_setpoint_scale; +- int8_t auto_setpoint_precision; ++ uint8_t auto_setpoint_precision; + } uic_mqtt_dotdot_unify_humidity_control_state_t; + + typedef struct { +@@ -41585,9 +41585,9 @@ typedef struct { + typedef struct { + SetpointType type; + +- int8_t precision; ++ uint8_t precision; + +- int8_t scale; ++ uint8_t scale; + + int32_t value; + } uic_mqtt_dotdot_unify_humidity_control_command_setpoint_set_fields_t; +@@ -41975,7 +41975,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_unr + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -42125,7 +42125,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_u + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +@@ -42275,7 +42275,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( + */ + sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ); + +diff --git a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h +index 9dabf5aedf..9f094654e3 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h ++++ b/components/uic_dotdot_mqtt/zap-generated/include/dotdot_mqtt_attributes.h +@@ -48,28 +48,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_zcl_version_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t zcl_version ++ uint8_t zcl_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_application_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t application_version ++ uint8_t application_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_stack_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t stack_version ++ uint8_t stack_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_hw_version_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t hw_version ++ uint8_t hw_version + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_manufacturer_name_callback_t)( + dotdot_unid_t unid, +@@ -118,7 +118,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_product_code_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t product_code ++ const char* product_code + ); + typedef sl_status_t (*uic_mqtt_dotdot_basic_attribute_producturl_callback_t)( + dotdot_unid_t unid, +@@ -196,14 +196,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mains_voltage ++ uint16_t mains_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t mains_frequency ++ uint8_t mains_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -217,35 +217,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mains_voltage_min_threshold ++ uint16_t mains_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltage_max_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mains_voltage_max_threshold ++ uint16_t mains_voltage_max_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_mains_voltage_dwell_trip_point_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mains_voltage_dwell_trip_point ++ uint16_t mains_voltage_dwell_trip_point + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_voltage ++ uint8_t battery_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_percentage_remaining ++ uint8_t battery_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -266,21 +266,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_batterya_hr_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t batterya_hr_rating ++ uint16_t batterya_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_quantity ++ uint8_t battery_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_rated_voltage ++ uint8_t battery_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -294,56 +294,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_volt + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_voltage_min_threshold ++ uint8_t battery_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_voltage_threshold1 ++ uint8_t battery_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_voltage_threshold2 ++ uint8_t battery_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_voltage_threshold3 ++ uint8_t battery_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_percentage_min_threshold ++ uint8_t battery_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_percentage_threshold1 ++ uint8_t battery_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_percentage_threshold2 ++ uint8_t battery_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery_percentage_threshold3 ++ uint8_t battery_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -357,14 +357,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_voltage ++ uint8_t battery2_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_percentage_remaining ++ uint8_t battery2_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -385,21 +385,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2a_hr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t battery2a_hr_rating ++ uint16_t battery2a_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_quantity ++ uint8_t battery2_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_rated_voltage ++ uint8_t battery2_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -413,56 +413,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_voltage_min_threshold ++ uint8_t battery2_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_voltage_threshold1 ++ uint8_t battery2_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_voltage_threshold2 ++ uint8_t battery2_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_voltage_threshold3 ++ uint8_t battery2_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_percentage_min_threshold ++ uint8_t battery2_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_percentage_threshold1 ++ uint8_t battery2_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_percentage_threshold2 ++ uint8_t battery2_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery2_percentage_threshold3 ++ uint8_t battery2_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery2_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -476,14 +476,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_voltage ++ uint8_t battery3_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_remaining_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_percentage_remaining ++ uint8_t battery3_percentage_remaining + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_manufacturer_callback_t)( + dotdot_unid_t unid, +@@ -504,21 +504,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3a_hr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t battery3a_hr_rating ++ uint16_t battery3a_hr_rating + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_quantity ++ uint8_t battery3_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_rated_voltage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_rated_voltage ++ uint8_t battery3_rated_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -532,56 +532,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_vol + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_voltage_min_threshold ++ uint8_t battery3_voltage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_voltage_threshold1 ++ uint8_t battery3_voltage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_voltage_threshold2 ++ uint8_t battery3_voltage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_voltage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_voltage_threshold3 ++ uint8_t battery3_voltage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_min_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_percentage_min_threshold ++ uint8_t battery3_percentage_min_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold1_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_percentage_threshold1 ++ uint8_t battery3_percentage_threshold1 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold2_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_percentage_threshold2 ++ uint8_t battery3_percentage_threshold2 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_percentage_threshold3_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t battery3_percentage_threshold3 ++ uint8_t battery3_percentage_threshold3 + ); + typedef sl_status_t (*uic_mqtt_dotdot_power_configuration_attribute_battery3_alarm_state_callback_t)( + dotdot_unid_t unid, +@@ -617,7 +617,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t over_temp_total_dwell ++ uint16_t over_temp_total_dwell + ); + typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute_device_temp_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -645,14 +645,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t low_temp_dwell_trip_point ++ uint32_t low_temp_dwell_trip_point + ); + typedef sl_status_t (*uic_mqtt_dotdot_device_temperature_configuration_attribute_high_temp_dwell_trip_point_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t high_temp_dwell_trip_point ++ uint32_t high_temp_dwell_trip_point + ); + // Callback types used by the identify cluster + typedef sl_status_t (*uic_mqtt_dotdot_identify_attribute_identify_time_callback_t)( +@@ -660,7 +660,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_identify_attribute_identify_time_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t identify_time ++ uint16_t identify_time + ); + // Callback types used by the groups cluster + typedef sl_status_t (*uic_mqtt_dotdot_groups_attribute_name_support_callback_t)( +@@ -676,21 +676,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_scene_count_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t scene_count ++ uint8_t scene_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_current_scene_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_scene ++ uint8_t current_scene + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_current_group_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t * current_group ++ uint16_t current_group + ); + typedef sl_status_t (*uic_mqtt_dotdot_scenes_attribute_scene_valid_callback_t)( + dotdot_unid_t unid, +@@ -741,14 +741,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_on_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t on_time ++ uint16_t on_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_off_wait_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t off_wait_time ++ uint16_t off_wait_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_on_off_attribute_start_up_on_off_callback_t)( + dotdot_unid_t unid, +@@ -763,49 +763,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_current_level_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_level ++ uint8_t current_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_remaining_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t remaining_time ++ uint16_t remaining_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_min_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t min_level ++ uint8_t min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t max_level ++ uint8_t max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_current_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t current_frequency ++ uint16_t current_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_min_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_frequency ++ uint16_t min_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_max_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_frequency ++ uint16_t max_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_options_callback_t)( + dotdot_unid_t unid, +@@ -819,42 +819,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_off_transition_time_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t on_off_transition_time ++ uint16_t on_off_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t on_level ++ uint8_t on_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_on_transition_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t on_transition_time ++ uint16_t on_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_off_transition_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t off_transition_time ++ uint16_t off_transition_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_default_move_rate_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t default_move_rate ++ uint16_t default_move_rate + ); + typedef sl_status_t (*uic_mqtt_dotdot_level_attribute_start_up_current_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t start_up_current_level ++ uint8_t start_up_current_level + ); + // Callback types used by the alarms cluster + typedef sl_status_t (*uic_mqtt_dotdot_alarms_attribute_alarm_count_callback_t)( +@@ -862,7 +862,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_alarms_attribute_alarm_count_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t alarm_count ++ uint16_t alarm_count + ); + // Callback types used by the time cluster + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_callback_t)( +@@ -870,7 +870,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t time ++ uint32_t time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_time_status_callback_t)( + dotdot_unid_t unid, +@@ -891,14 +891,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_start_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t dst_start ++ uint32_t dst_start + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_end_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t dst_end ++ uint32_t dst_end + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_dst_shift_callback_t)( + dotdot_unid_t unid, +@@ -912,28 +912,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_standard_time_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t standard_time ++ uint32_t standard_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_local_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t local_time ++ uint32_t local_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_last_set_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t last_set_time ++ uint32_t last_set_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_time_attribute_valid_until_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t valid_until_time ++ uint32_t valid_until_time + ); + // Callback types used by the poll_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_callback_t)( +@@ -941,49 +941,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_c + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t check_in_interval ++ uint32_t check_in_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_long_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t long_poll_interval ++ uint32_t long_poll_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_short_poll_interval_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t short_poll_interval ++ uint16_t short_poll_interval + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_fast_poll_timeout_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t fast_poll_timeout ++ uint16_t fast_poll_timeout + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_check_in_interval_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t check_in_interval_min ++ uint32_t check_in_interval_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_long_poll_interval_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t long_poll_interval_min ++ uint32_t long_poll_interval_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_poll_control_attribute_fast_poll_timeout_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t fast_poll_timeout_max ++ uint16_t fast_poll_timeout_max + ); + // Callback types used by the shade_configuration cluster + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_physical_closed_limit_callback_t)( +@@ -991,14 +991,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_physical_clo + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t physical_closed_limit ++ uint16_t physical_closed_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_motor_step_size_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t motor_step_size ++ uint8_t motor_step_size + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_status_callback_t)( + dotdot_unid_t unid, +@@ -1012,7 +1012,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_closed_limit + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t closed_limit ++ uint16_t closed_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_shade_configuration_attribute_mode_callback_t)( + dotdot_unid_t unid, +@@ -1055,98 +1055,98 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_door_open_events_callb + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t door_open_events ++ uint32_t door_open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_door_closed_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t door_closed_events ++ uint32_t door_closed_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_open_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t open_period ++ uint16_t open_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_log_records_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_log_records_supported ++ uint16_t number_of_log_records_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_total_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_total_users_supported ++ uint16_t number_of_total_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_pin_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_pin_users_supported ++ uint16_t number_of_pin_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_rfid_users_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_rfid_users_supported ++ uint16_t number_of_rfid_users_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_week_day_schedules_supported_per_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_week_day_schedules_supported_per_user ++ uint8_t number_of_week_day_schedules_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_year_day_schedules_supported_per_user_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_year_day_schedules_supported_per_user ++ uint8_t number_of_year_day_schedules_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_holiday_schedules_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_holiday_schedules_supported ++ uint8_t number_of_holiday_schedules_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_max_pin_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t max_pin_code_length ++ uint8_t max_pin_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_min_pin_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t min_pin_code_length ++ uint8_t min_pin_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_max_rfid_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t max_rfid_code_length ++ uint8_t max_rfid_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_min_rfid_code_length_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t min_rfid_code_length ++ uint8_t min_rfid_code_length + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_credential_rules_support_callback_t)( + dotdot_unid_t unid, +@@ -1160,7 +1160,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_number_of_credentials_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_credentials_supported_per_user ++ uint8_t number_of_credentials_supported_per_user + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_enable_logging_callback_t)( + dotdot_unid_t unid, +@@ -1181,21 +1181,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_led_settings_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t led_settings ++ uint8_t led_settings + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_auto_relock_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t auto_relock_time ++ uint32_t auto_relock_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_sound_volume_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t sound_volume ++ uint8_t sound_volume + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_operating_mode_callback_t)( + dotdot_unid_t unid, +@@ -1258,14 +1258,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_wrong_code_entry_limit + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t wrong_code_entry_limit ++ uint8_t wrong_code_entry_limit + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_user_code_temporary_disable_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t user_code_temporary_disable_time ++ uint8_t user_code_temporary_disable_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_send_pin_over_the_air_callback_t)( + dotdot_unid_t unid, +@@ -1293,7 +1293,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_expiring_user_timeout_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t expiring_user_timeout ++ uint16_t expiring_user_timeout + ); + typedef sl_status_t (*uic_mqtt_dotdot_door_lock_attribute_alarm_mask_callback_t)( + dotdot_unid_t unid, +@@ -1371,42 +1371,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_physical_closed_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t physical_closed_limit_lift ++ uint16_t physical_closed_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_physical_closed_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t physical_closed_limit_tilt ++ uint16_t physical_closed_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t current_position_lift ++ uint16_t current_position_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t current_position_tilt ++ uint16_t current_position_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_number_of_actuations_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_actuations_lift ++ uint16_t number_of_actuations_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_number_of_actuations_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_actuations_tilt ++ uint16_t number_of_actuations_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_config_or_status_callback_t)( + dotdot_unid_t unid, +@@ -1420,63 +1420,63 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_position_lift_percentage ++ uint8_t current_position_lift_percentage + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_current_position_tilt_percentage_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_position_tilt_percentage ++ uint8_t current_position_tilt_percentage + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_open_limit_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t installed_open_limit_lift ++ uint16_t installed_open_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_closed_limit_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t installed_closed_limit_lift ++ uint16_t installed_closed_limit_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_open_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t installed_open_limit_tilt ++ uint16_t installed_open_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_installed_closed_limit_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t installed_closed_limit_tilt ++ uint16_t installed_closed_limit_tilt + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_velocity_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t velocity_lift ++ uint16_t velocity_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_acceleration_time_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t acceleration_time_lift ++ uint16_t acceleration_time_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_deceleration_time_lift_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t deceleration_time_lift ++ uint16_t deceleration_time_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_mode_callback_t)( + dotdot_unid_t unid, +@@ -1490,14 +1490,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_intermediate_set + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t intermediate_setpoints_lift ++ const char* intermediate_setpoints_lift + ); + typedef sl_status_t (*uic_mqtt_dotdot_window_covering_attribute_intermediate_setpoints_tilt_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t intermediate_setpoints_tilt ++ const char* intermediate_setpoints_tilt + ); + // Callback types used by the barrier_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_moving_state_callback_t)( +@@ -1526,49 +1526,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_open_events_call + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t open_events ++ uint16_t open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_close_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t close_events ++ uint16_t close_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_command_open_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t command_open_events ++ uint16_t command_open_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_command_close_events_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t command_close_events ++ uint16_t command_close_events + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_open_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t open_period ++ uint16_t open_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_close_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t close_period ++ uint16_t close_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_barrier_control_attribute_barrier_position_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t barrier_position ++ uint8_t barrier_position + ); + // Callback types used by the pump_configuration_and_control cluster + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_pressure_callback_t)( +@@ -1583,14 +1583,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_speed ++ uint16_t max_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_flow ++ uint16_t max_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_pressure_callback_t)( + dotdot_unid_t unid, +@@ -1625,28 +1625,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_const_speed ++ uint16_t min_const_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_const_speed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_const_speed ++ uint16_t max_const_speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_const_flow ++ uint16_t min_const_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_max_const_flow_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_const_flow ++ uint16_t max_const_flow + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_min_const_temp_callback_t)( + dotdot_unid_t unid, +@@ -1695,28 +1695,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_s + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t speed ++ uint16_t speed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_lifetime_running_hours_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t lifetime_running_hours ++ uint32_t lifetime_running_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_power_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t power ++ uint32_t power + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_lifetime_energy_consumed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t lifetime_energy_consumed ++ uint32_t lifetime_energy_consumed + ); + typedef sl_status_t (*uic_mqtt_dotdot_pump_configuration_and_control_attribute_operation_mode_callback_t)( + dotdot_unid_t unid, +@@ -1794,14 +1794,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_pi_cooling_demand_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t pi_cooling_demand ++ uint8_t pi_cooling_demand + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_pi_heating_demand_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t pi_heating_demand ++ uint8_t pi_heating_demand + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_hvac_system_type_configuration_callback_t)( + dotdot_unid_t unid, +@@ -1927,14 +1927,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_number_of_weekly_tran + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_weekly_transitions ++ uint8_t number_of_weekly_transitions + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_number_of_daily_transitions_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_daily_transitions ++ uint8_t number_of_daily_transitions + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_temperature_setpoint_hold_callback_t)( + dotdot_unid_t unid, +@@ -1948,7 +1948,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_temperature_setpoint_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t temperature_setpoint_hold_duration ++ uint16_t temperature_setpoint_hold_duration + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_thermostat_programming_operation_mode_callback_t)( + dotdot_unid_t unid, +@@ -1983,56 +1983,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_setpoint_change_sourc + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t setpoint_change_source_timestamp ++ uint32_t setpoint_change_source_timestamp + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t occupied_setback ++ uint8_t occupied_setback + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t occupied_setback_min ++ uint8_t occupied_setback_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_occupied_setback_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t occupied_setback_max ++ uint8_t occupied_setback_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t unoccupied_setback ++ uint8_t unoccupied_setback + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t unoccupied_setback_min ++ uint8_t unoccupied_setback_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_unoccupied_setback_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t unoccupied_setback_max ++ uint8_t unoccupied_setback_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_emergency_heat_delta_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t emergency_heat_delta ++ uint8_t emergency_heat_delta + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_type_callback_t)( + dotdot_unid_t unid, +@@ -2046,7 +2046,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_capacity_callback_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_capacity ++ uint16_t ac_capacity + ); + typedef sl_status_t (*uic_mqtt_dotdot_thermostat_attribute_ac_refrigerant_type_callback_t)( + dotdot_unid_t unid, +@@ -2111,21 +2111,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relativ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t relative_humidity ++ uint8_t relative_humidity + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumidification_cooling_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t dehumidification_cooling ++ uint8_t dehumidification_cooling + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_rh_dehumidification_setpoint_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t rh_dehumidification_setpoint ++ uint8_t rh_dehumidification_setpoint + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relative_humidity_mode_callback_t)( + dotdot_unid_t unid, +@@ -2146,14 +2146,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumid + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t dehumidification_hysteresis ++ uint8_t dehumidification_hysteresis + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_dehumidification_max_cool_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t dehumidification_max_cool ++ uint8_t dehumidification_max_cool + ); + typedef sl_status_t (*uic_mqtt_dotdot_dehumidification_control_attribute_relative_humidity_display_callback_t)( + dotdot_unid_t unid, +@@ -2190,35 +2190,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_current_hue_callba + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_hue ++ uint8_t current_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_current_saturation_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_saturation ++ uint8_t current_saturation + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_remaining_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t remaining_time ++ uint16_t remaining_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_currentx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t currentx ++ uint16_t currentx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_currenty_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t currenty ++ uint16_t currenty + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_drift_compensation_callback_t)( + dotdot_unid_t unid, +@@ -2239,7 +2239,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temperature_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_temperature_mireds ++ uint16_t color_temperature_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_mode_callback_t)( + dotdot_unid_t unid, +@@ -2260,217 +2260,217 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_number_of_primarie + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_primaries ++ uint8_t number_of_primaries + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary1x ++ uint16_t primary1x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary1y ++ uint16_t primary1y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary1_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary1_intensity ++ uint8_t primary1_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary2x ++ uint16_t primary2x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary2y ++ uint16_t primary2y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary2_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary2_intensity ++ uint8_t primary2_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary3x ++ uint16_t primary3x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary3y ++ uint16_t primary3y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary3_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary3_intensity ++ uint8_t primary3_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary4x ++ uint16_t primary4x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary4y ++ uint16_t primary4y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary4_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary4_intensity ++ uint8_t primary4_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary5x ++ uint16_t primary5x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary5y ++ uint16_t primary5y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary5_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary5_intensity ++ uint8_t primary5_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6x_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary6x ++ uint16_t primary6x + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6y_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t primary6y ++ uint16_t primary6y + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_primary6_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t primary6_intensity ++ uint8_t primary6_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_white_pointx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t white_pointx ++ uint16_t white_pointx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_white_pointy_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t white_pointy ++ uint16_t white_pointy + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointrx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointrx ++ uint16_t color_pointrx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointry ++ uint16_t color_pointry + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointr_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t color_pointr_intensity ++ uint8_t color_pointr_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointgx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointgx ++ uint16_t color_pointgx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointgy_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointgy ++ uint16_t color_pointgy + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointg_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t color_pointg_intensity ++ uint8_t color_pointg_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointbx_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointbx ++ uint16_t color_pointbx + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointby_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_pointby ++ uint16_t color_pointby + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_pointb_intensity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t color_pointb_intensity ++ uint8_t color_pointb_intensity + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_enhanced_current_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t enhanced_current_hue ++ uint16_t enhanced_current_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_enhanced_color_mode_callback_t)( + dotdot_unid_t unid, +@@ -2484,35 +2484,35 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_active_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t color_loop_active ++ uint8_t color_loop_active + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_direction_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t color_loop_direction ++ uint8_t color_loop_direction + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_loop_time ++ uint16_t color_loop_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_start_enhanced_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_loop_start_enhanced_hue ++ uint16_t color_loop_start_enhanced_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_loop_stored_enhanced_hue_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_loop_stored_enhanced_hue ++ uint16_t color_loop_stored_enhanced_hue + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_capabilities_callback_t)( + dotdot_unid_t unid, +@@ -2526,28 +2526,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temp_physica + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_temp_physical_min_mireds ++ uint16_t color_temp_physical_min_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_color_temp_physical_max_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t color_temp_physical_max_mireds ++ uint16_t color_temp_physical_max_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_couple_color_temp_to_level_min_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t couple_color_temp_to_level_min_mireds ++ uint16_t couple_color_temp_to_level_min_mireds + ); + typedef sl_status_t (*uic_mqtt_dotdot_color_control_attribute_start_up_color_temperature_mireds_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t start_up_color_temperature_mireds ++ uint16_t start_up_color_temperature_mireds + ); + // Callback types used by the ballast_configuration cluster + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_min_level_callback_t)( +@@ -2555,14 +2555,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_m + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t physical_min_level ++ uint8_t physical_min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_physical_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t physical_max_level ++ uint8_t physical_max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_ballast_status_callback_t)( + dotdot_unid_t unid, +@@ -2576,49 +2576,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_min_level_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t min_level ++ uint8_t min_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_max_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t max_level ++ uint8_t max_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_power_on_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t power_on_level ++ uint8_t power_on_level + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_power_on_fade_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t power_on_fade_time ++ uint16_t power_on_fade_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_intrinsic_ballast_factor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t intrinsic_ballast_factor ++ uint8_t intrinsic_ballast_factor + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_ballast_factor_adjustment_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t ballast_factor_adjustment ++ uint8_t ballast_factor_adjustment + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_quantity_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t lamp_quantity ++ uint8_t lamp_quantity + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_type_callback_t)( + dotdot_unid_t unid, +@@ -2639,14 +2639,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_rated + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t lamp_rated_hours ++ uint32_t lamp_rated_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_burn_hours_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t lamp_burn_hours ++ uint32_t lamp_burn_hours + ); + typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_alarm_mode_callback_t)( + dotdot_unid_t unid, +@@ -2660,7 +2660,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_ballast_configuration_attribute_lamp_burn_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t lamp_burn_hours_trip_point ++ uint32_t lamp_burn_hours_trip_point + ); + // Callback types used by the illuminance_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_measured_value_callback_t)( +@@ -2668,28 +2668,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_measured + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_illuminance_measurement_attribute_light_sensor_type_callback_t)( + dotdot_unid_t unid, +@@ -2718,7 +2718,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_illuminance_level_sensing_attribute_illumi + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t illuminance_target_level ++ uint16_t illuminance_target_level + ); + // Callback types used by the temperature_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_temperature_measurement_attribute_measured_value_callback_t)( +@@ -2747,7 +2747,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_temperature_measurement_attribute_toleranc + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the pressure_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_measured_value_callback_t)( +@@ -2776,7 +2776,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_tolerance_c + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scaled_value_callback_t)( + dotdot_unid_t unid, +@@ -2804,7 +2804,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scaled_tole + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t scaled_tolerance ++ uint16_t scaled_tolerance + ); + typedef sl_status_t (*uic_mqtt_dotdot_pressure_measurement_attribute_scale_callback_t)( + dotdot_unid_t unid, +@@ -2819,28 +2819,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_measured_value_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_flow_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the relativity_humidity cluster + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_measured_value_callback_t)( +@@ -2848,28 +2848,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_measured_val + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_relativity_humidity_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the occupancy_sensing cluster + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_occupancy_callback_t)( +@@ -2898,63 +2898,63 @@ typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_occupied_t + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t pir_occupied_to_unoccupied_delay ++ uint16_t pir_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t pir_unoccupied_to_occupied_delay ++ uint16_t pir_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_pir_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t pir_unoccupied_to_occupied_threshold ++ uint8_t pir_unoccupied_to_occupied_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_occupied_to_unoccupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ultrasonic_occupied_to_unoccupied_delay ++ uint16_t ultrasonic_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ultrasonic_unoccupied_to_occupied_delay ++ uint16_t ultrasonic_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_ultrasonic_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t ultrasonic_unoccupied_to_occupied_threshold ++ uint8_t ultrasonic_unoccupied_to_occupied_threshold + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_occupied_to_unoccupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t physical_contact_occupied_to_unoccupied_delay ++ uint16_t physical_contact_occupied_to_unoccupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_unoccupied_to_occupied_delay_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t physical_contact_unoccupied_to_occupied_delay ++ uint16_t physical_contact_unoccupied_to_occupied_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_occupancy_sensing_attribute_physical_contact_unoccupied_to_occupied_threshold_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t physical_contact_unoccupied_to_occupied_threshold ++ uint8_t physical_contact_unoccupied_to_occupied_threshold + ); + // Callback types used by the soil_moisture cluster + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_measured_value_callback_t)( +@@ -2962,28 +2962,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_measured_value_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_soil_moisture_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the ph_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_measured_value_callback_t)( +@@ -2991,28 +2991,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_measured_value_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_ph_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the electrical_conductivity_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_measured_value_callback_t)( +@@ -3020,28 +3020,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attrib + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_conductivity_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the wind_speed_measurement cluster + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_measured_value_callback_t)( +@@ -3049,28 +3049,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_measured_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t measured_value ++ uint16_t measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_min_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t min_measured_value ++ uint16_t min_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_max_measured_value_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_measured_value ++ uint16_t max_measured_value + ); + typedef sl_status_t (*uic_mqtt_dotdot_wind_speed_measurement_attribute_tolerance_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t tolerance ++ uint16_t tolerance + ); + // Callback types used by the carbon_monoxide cluster + typedef sl_status_t (*uic_mqtt_dotdot_carbon_monoxide_attribute_measured_value_callback_t)( +@@ -3193,21 +3193,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_zoneid_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t zoneid ++ uint8_t zoneid + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_number_of_zone_sensitivity_levels_supported_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t number_of_zone_sensitivity_levels_supported ++ uint8_t number_of_zone_sensitivity_levels_supported + ); + typedef sl_status_t (*uic_mqtt_dotdot_ias_zone_attribute_current_zone_sensitivity_level_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t current_zone_sensitivity_level ++ uint8_t current_zone_sensitivity_level + ); + // Callback types used by the iaswd cluster + typedef sl_status_t (*uic_mqtt_dotdot_iaswd_attribute_max_duration_callback_t)( +@@ -3215,7 +3215,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_iaswd_attribute_max_duration_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t max_duration ++ uint16_t max_duration + ); + // Callback types used by the metering cluster + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_delivered_callback_t)( +@@ -3223,21 +3223,21 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_deliv + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t current_summation_delivered ++ uint64_t current_summation_delivered + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_summation_received_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t current_summation_received ++ uint64_t current_summation_received + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_delivered_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t current_max_demand_delivered ++ uint64_t current_max_demand_delivered + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_received_callback_t)( + dotdot_unid_t unid, +@@ -3258,28 +3258,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_reading_snap_shot_time_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t reading_snap_shot_time ++ uint32_t reading_snap_shot_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_delivered_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_max_demand_delivered_time ++ uint32_t current_max_demand_delivered_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_max_demand_received_time_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- uint8_t current_max_demand_received_time ++ uint32_t current_max_demand_received_time + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_default_update_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t default_update_period ++ uint8_t default_update_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_supply_status_callback_t)( + dotdot_unid_t unid, +@@ -3293,14 +3293,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_inlet_energy_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t current_inlet_energy_carrier_summation ++ uint64_t current_inlet_energy_carrier_summation + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_current_outlet_energy_carrier_summation_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t current_outlet_energy_carrier_summation ++ uint64_t current_outlet_energy_carrier_summation + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_inlet_temperature_callback_t)( + dotdot_unid_t unid, +@@ -3328,14 +3328,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_multiplier_callback_t)( + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t multiplier ++ uint32_t multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t divisor ++ uint32_t divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_metering_attribute_summation_formatting_callback_t)( + dotdot_unid_t unid, +@@ -3476,70 +3476,70 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_voltag + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_voltage_multiplier ++ uint16_t dc_voltage_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_voltage_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_voltage_divisor ++ uint16_t dc_voltage_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_current_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_current_multiplier ++ uint16_t dc_current_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_current_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_current_divisor ++ uint16_t dc_current_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_power_multiplier ++ uint16_t dc_power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t dc_power_divisor ++ uint16_t dc_power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_frequency ++ uint16_t ac_frequency + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_frequency_min ++ uint16_t ac_frequency_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_frequency_max ++ uint16_t ac_frequency_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_neutral_current_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t neutral_current ++ uint16_t neutral_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_total_active_power_callback_t)( + dotdot_unid_t unid, +@@ -3560,7 +3560,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_total_app + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t total_apparent_power ++ uint32_t total_apparent_power + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_measured1st_harmonic_current_callback_t)( + dotdot_unid_t unid, +@@ -3651,28 +3651,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_freque + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_frequency_multiplier ++ uint16_t ac_frequency_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_frequency_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_frequency_divisor ++ uint16_t ac_frequency_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t power_multiplier ++ uint32_t power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t power_divisor ++ uint32_t power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_harmonic_current_multiplier_callback_t)( + dotdot_unid_t unid, +@@ -3693,7 +3693,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_curr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t line_current ++ uint16_t line_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_callback_t)( + dotdot_unid_t unid, +@@ -3714,42 +3714,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage ++ uint16_t rms_voltage + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_min ++ uint16_t rms_voltage_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_max ++ uint16_t rms_voltage_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current ++ uint16_t rms_current + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_min ++ uint16_t rms_current_min + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_max ++ uint16_t rms_current_max + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_callback_t)( + dotdot_unid_t unid, +@@ -3784,7 +3784,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t apparent_power ++ uint16_t apparent_power + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_callback_t)( + dotdot_unid_t unid, +@@ -3798,91 +3798,91 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_voltage_measurement_period ++ uint16_t average_rms_voltage_measurement_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_over_voltage_counter ++ uint16_t average_rms_over_voltage_counter + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_under_voltage_counter ++ uint16_t average_rms_under_voltage_counter + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_over_voltage_period ++ uint16_t rms_extreme_over_voltage_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_under_voltage_period ++ uint16_t rms_extreme_under_voltage_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_sag_period ++ uint16_t rms_voltage_sag_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_swell_period ++ uint16_t rms_voltage_swell_period + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_voltage_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_voltage_multiplier ++ uint16_t ac_voltage_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_voltage_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_voltage_divisor ++ uint16_t ac_voltage_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_current_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_current_multiplier ++ uint16_t ac_current_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_current_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_current_divisor ++ uint16_t ac_current_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_power_multiplier_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_power_multiplier ++ uint16_t ac_power_multiplier + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_ac_power_divisor_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t ac_power_divisor ++ uint16_t ac_power_divisor + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_dc_overload_alarms_mask_callback_t)( + dotdot_unid_t unid, +@@ -3987,7 +3987,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_curr + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t line_current_phb ++ uint16_t line_current_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_phb_callback_t)( + dotdot_unid_t unid, +@@ -4008,42 +4008,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_phb ++ uint16_t rms_voltage_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_min_phb ++ uint16_t rms_voltage_min_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_max_phb ++ uint16_t rms_voltage_max_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_phb ++ uint16_t rms_current_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_min_phb ++ uint16_t rms_current_min_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_max_phb ++ uint16_t rms_current_max_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_phb_callback_t)( + dotdot_unid_t unid, +@@ -4078,7 +4078,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t apparent_power_phb ++ uint16_t apparent_power_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_phb_callback_t)( + dotdot_unid_t unid, +@@ -4092,56 +4092,56 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_voltage_measurement_period_phb ++ uint16_t average_rms_voltage_measurement_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_over_voltage_counter_phb ++ uint16_t average_rms_over_voltage_counter_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_under_voltage_counter_phb ++ uint16_t average_rms_under_voltage_counter_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_over_voltage_period_phb ++ uint16_t rms_extreme_over_voltage_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_under_voltage_period_phb ++ uint16_t rms_extreme_under_voltage_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_sag_period_phb ++ uint16_t rms_voltage_sag_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_phb_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_swell_period_phb ++ uint16_t rms_voltage_swell_period_phb + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_line_current_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t line_current_phc ++ uint16_t line_current_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_current_phc_callback_t)( + dotdot_unid_t unid, +@@ -4162,42 +4162,42 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_volta + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_phc ++ uint16_t rms_voltage_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_min_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_min_phc ++ uint16_t rms_voltage_min_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_max_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_max_phc ++ uint16_t rms_voltage_max_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_phc ++ uint16_t rms_current_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_min_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_min_phc ++ uint16_t rms_current_min_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_current_max_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_current_max_phc ++ uint16_t rms_current_max_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_active_power_phc_callback_t)( + dotdot_unid_t unid, +@@ -4232,7 +4232,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_apparent_ + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t apparent_power_phc ++ uint16_t apparent_power_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_power_factor_phc_callback_t)( + dotdot_unid_t unid, +@@ -4246,49 +4246,49 @@ typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_r + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_voltage_measurement_period_phc ++ uint16_t average_rms_voltage_measurement_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_over_voltage_counter_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_over_voltage_counter_phc ++ uint16_t average_rms_over_voltage_counter_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_average_rms_under_voltage_counter_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_rms_under_voltage_counter_phc ++ uint16_t average_rms_under_voltage_counter_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_over_voltage_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_over_voltage_period_phc ++ uint16_t rms_extreme_over_voltage_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_extreme_under_voltage_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_extreme_under_voltage_period_phc ++ uint16_t rms_extreme_under_voltage_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_sag_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_sag_period_phc ++ uint16_t rms_voltage_sag_period_phc + ); + typedef sl_status_t (*uic_mqtt_dotdot_electrical_measurement_attribute_rms_voltage_swell_period_phc_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t rms_voltage_swell_period_phc ++ uint16_t rms_voltage_swell_period_phc + ); + // Callback types used by the diagnostics cluster + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_number_of_resets_callback_t)( +@@ -4296,217 +4296,217 @@ typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_number_of_resets_cal + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t number_of_resets ++ uint16_t number_of_resets + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_persistent_memory_writes_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t persistent_memory_writes ++ uint16_t persistent_memory_writes + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_rx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t mac_rx_bcast ++ uint32_t mac_rx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t mac_tx_bcast ++ uint32_t mac_tx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_rx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t mac_rx_ucast ++ uint32_t mac_rx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t mac_tx_ucast ++ uint32_t mac_tx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_retry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mac_tx_ucast_retry ++ uint16_t mac_tx_ucast_retry + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_mac_tx_ucast_fail_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t mac_tx_ucast_fail ++ uint16_t mac_tx_ucast_fail + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_rx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_rx_bcast ++ uint16_t aps_rx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_bcast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_tx_bcast ++ uint16_t aps_tx_bcast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_rx_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_rx_ucast ++ uint16_t aps_rx_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_success_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_tx_ucast_success ++ uint16_t aps_tx_ucast_success + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_retry_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_tx_ucast_retry ++ uint16_t aps_tx_ucast_retry + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_tx_ucast_fail_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_tx_ucast_fail ++ uint16_t aps_tx_ucast_fail + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_route_disc_initiated_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t route_disc_initiated ++ uint16_t route_disc_initiated + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_added_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t neighbor_added ++ uint16_t neighbor_added + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_removed_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t neighbor_removed ++ uint16_t neighbor_removed + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_neighbor_stale_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t neighbor_stale ++ uint16_t neighbor_stale + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_join_indication_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t join_indication ++ uint16_t join_indication + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_child_moved_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t child_moved ++ uint16_t child_moved + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_nwkfc_failure_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t nwkfc_failure ++ uint16_t nwkfc_failure + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_apsfc_failure_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t apsfc_failure ++ uint16_t apsfc_failure + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_unauthorized_key_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_unauthorized_key ++ uint16_t aps_unauthorized_key + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_nwk_decrypt_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t nwk_decrypt_failures ++ uint16_t nwk_decrypt_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_aps_decrypt_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t aps_decrypt_failures ++ uint16_t aps_decrypt_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_packet_buffer_allocate_failures_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t packet_buffer_allocate_failures ++ uint16_t packet_buffer_allocate_failures + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_relayed_ucast_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t relayed_ucast ++ uint16_t relayed_ucast + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_phy_to_mac_queue_limit_reached_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t phy_to_mac_queue_limit_reached ++ uint16_t phy_to_mac_queue_limit_reached + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_packet_validate_drop_count_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t packet_validate_drop_count ++ uint16_t packet_validate_drop_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_average_mac_retry_per_aps_message_sent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t average_mac_retry_per_aps_message_sent ++ uint16_t average_mac_retry_per_aps_message_sent + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_last_messagelqi_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t last_messagelqi ++ uint8_t last_messagelqi + ); + typedef sl_status_t (*uic_mqtt_dotdot_diagnostics_attribute_last_messagerssi_callback_t)( + dotdot_unid_t unid, +@@ -4537,7 +4537,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_endpoint_id_list_callback_ + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, + size_t endpoint_id_list_count, +- const int8_t* endpoint_id_list ++ const uint8_t* endpoint_id_list + ); + typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_network_status_callback_t)( + dotdot_unid_t unid, +@@ -4558,7 +4558,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_maximum_command_delay_call + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t maximum_command_delay ++ uint32_t maximum_command_delay + ); + typedef sl_status_t (*uic_mqtt_dotdot_state_attribute_network_list_callback_t)( + dotdot_unid_t unid, +@@ -4598,7 +4598,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_reporting_interva + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t reporting_interval_seconds ++ uint32_t reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_cpu_usage_percent_callback_t)( + dotdot_unid_t unid, +@@ -4740,7 +4740,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_uptime_minutes_ca + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t uptime_minutes ++ uint64_t uptime_minutes + ); + typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_current_temperature_celcius_callback_t)( + dotdot_unid_t unid, +@@ -4789,7 +4789,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_system_metrics_attribute_system_interrupts + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t system_interrupts ++ uint64_t system_interrupts + ); + // Callback types used by the application_monitoring cluster + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_application_name_callback_t)( +@@ -4826,14 +4826,14 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_uptime_mi + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t uptime_minutes ++ uint64_t uptime_minutes + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_process_id_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t process_id ++ uint64_t process_id + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_hostname_callback_t)( + dotdot_unid_t unid, +@@ -4868,28 +4868,28 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_stat + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t mqtt_statistics_reporting_interval_seconds ++ uint32_t mqtt_statistics_reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_messages_sent_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t mqtt_messages_sent ++ uint64_t mqtt_messages_sent + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_messages_received_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t mqtt_messages_received ++ uint64_t mqtt_messages_received + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_subscription_count_callback_t)( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int64_t mqtt_subscription_count ++ uint64_t mqtt_subscription_count + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_mqtt_average_delivery_time_seconds_callback_t)( + dotdot_unid_t unid, +@@ -4917,7 +4917,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_applicati + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int32_t application_statistics_reporting_interval_seconds ++ uint32_t application_statistics_reporting_interval_seconds + ); + typedef sl_status_t (*uic_mqtt_dotdot_application_monitoring_attribute_application_cpu_usage_percent_callback_t)( + dotdot_unid_t unid, +@@ -4984,7 +4984,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_user_u + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int16_t supported_user_unique_identifiers ++ uint16_t supported_user_unique_identifiers + ); + typedef sl_status_t (*uic_mqtt_dotdot_user_credential_attribute_supported_credential_rules_callback_t)( + dotdot_unid_t unid, +@@ -5158,7 +5158,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_humidifie + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t humidifier_setpoint_precision ++ uint8_t humidifier_setpoint_precision + ); + typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_dehumidifier_setpoint_min_callback_t)( + dotdot_unid_t unid, +@@ -5193,7 +5193,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_dehumidif + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t dehumidifier_setpoint_precision ++ uint8_t dehumidifier_setpoint_precision + ); + typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_auto_setpoint_min_callback_t)( + dotdot_unid_t unid, +@@ -5228,7 +5228,7 @@ typedef sl_status_t (*uic_mqtt_dotdot_unify_humidity_control_attribute_auto_setp + dotdot_endpoint_id_t endpoint, + bool unretained, + uic_mqtt_dotdot_attribute_update_type_t update_type, +- int8_t auto_setpoint_precision ++ uint8_t auto_setpoint_precision + ); + + #ifdef __cplusplus +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp +index 8e00af65dd..2ad8e173db 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.cpp +@@ -394,7 +394,7 @@ static void uic_mqtt_dotdot_on_basic_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_basic_zcl_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -464,7 +464,7 @@ sl_status_t uic_mqtt_dotdot_basic_zcl_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_application_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -534,7 +534,7 @@ sl_status_t uic_mqtt_dotdot_basic_application_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_stack_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -604,7 +604,7 @@ sl_status_t uic_mqtt_dotdot_basic_stack_version_unretain( + + sl_status_t uic_mqtt_dotdot_basic_hw_version_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -1091,7 +1091,7 @@ sl_status_t uic_mqtt_dotdot_basic_generic_device_type_unretain( + + sl_status_t uic_mqtt_dotdot_basic_product_code_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2144,7 +2144,7 @@ static void uic_mqtt_dotdot_on_power_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2214,7 +2214,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2353,7 +2353,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2423,7 +2423,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2493,7 +2493,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2563,7 +2563,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2633,7 +2633,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2842,7 +2842,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2912,7 +2912,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_batterya_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -2982,7 +2982,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3121,7 +3121,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3191,7 +3191,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3261,7 +3261,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3331,7 +3331,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3401,7 +3401,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_unret + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3471,7 +3471,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3541,7 +3541,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3611,7 +3611,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_un + + sl_status_t uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3750,7 +3750,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery_alarm_state_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -3820,7 +3820,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4029,7 +4029,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4099,7 +4099,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4169,7 +4169,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4308,7 +4308,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4378,7 +4378,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4448,7 +4448,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4518,7 +4518,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4588,7 +4588,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4658,7 +4658,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshol + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4728,7 +4728,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4798,7 +4798,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -4937,7 +4937,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery2_alarm_state_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5007,7 +5007,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5216,7 +5216,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_size_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5286,7 +5286,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5356,7 +5356,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_quantity_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5495,7 +5495,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_alarm_mask_unretain( + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5565,7 +5565,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5635,7 +5635,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5705,7 +5705,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5775,7 +5775,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_unre + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5845,7 +5845,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshol + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5915,7 +5915,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -5985,7 +5985,7 @@ sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_u + + sl_status_t uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6540,7 +6540,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_max_temp_experience + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6819,7 +6819,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_threshold + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -6889,7 +6889,7 @@ sl_status_t uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip + + sl_status_t uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -7185,7 +7185,7 @@ void uic_mqtt_dotdot_on_identify_identify( + return; + } + +- int16_t identify_time = {}; ++ uint16_t identify_time = {}; + + + nlohmann::json jsn; +@@ -7244,7 +7244,7 @@ static void uic_mqtt_dotdot_on_generated_identify_identify( + return; + } + +- int16_t identify_time = {}; ++ uint16_t identify_time = {}; + + + nlohmann::json jsn; +@@ -7304,7 +7304,7 @@ void uic_mqtt_dotdot_on_identify_identify_query_response( + return; + } + +- int16_t timeout = {}; ++ uint16_t timeout = {}; + + + nlohmann::json jsn; +@@ -7363,7 +7363,7 @@ static void uic_mqtt_dotdot_on_generated_identify_identify_query_response( + return; + } + +- int16_t timeout = {}; ++ uint16_t timeout = {}; + + + nlohmann::json jsn; +@@ -7759,7 +7759,7 @@ static void uic_mqtt_dotdot_on_identify_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_identify_identify_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -8297,7 +8297,7 @@ void uic_mqtt_dotdot_on_groups_add_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -8361,7 +8361,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -8427,7 +8427,7 @@ void uic_mqtt_dotdot_on_groups_add_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8491,7 +8491,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8555,7 +8555,7 @@ void uic_mqtt_dotdot_on_groups_view_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8614,7 +8614,7 @@ static void uic_mqtt_dotdot_on_generated_groups_view_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -8675,7 +8675,7 @@ void uic_mqtt_dotdot_on_groups_view_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -8744,7 +8744,7 @@ static void uic_mqtt_dotdot_on_generated_groups_view_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -8813,7 +8813,7 @@ void uic_mqtt_dotdot_on_groups_get_group_membership( + return; + } + +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8873,7 +8873,7 @@ static void uic_mqtt_dotdot_on_generated_groups_get_group_membership( + return; + } + +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8934,8 +8934,8 @@ void uic_mqtt_dotdot_on_groups_get_group_membership_response( + return; + } + +- int8_t capacity = {}; +- std::vector group_list; ++ uint8_t capacity = {}; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -8999,8 +8999,8 @@ static void uic_mqtt_dotdot_on_generated_groups_get_group_membership_response( + return; + } + +- int8_t capacity = {}; +- std::vector group_list; ++ uint8_t capacity = {}; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -9065,7 +9065,7 @@ void uic_mqtt_dotdot_on_groups_remove_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9124,7 +9124,7 @@ static void uic_mqtt_dotdot_on_generated_groups_remove_group( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9185,7 +9185,7 @@ void uic_mqtt_dotdot_on_groups_remove_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9249,7 +9249,7 @@ static void uic_mqtt_dotdot_on_generated_groups_remove_group_response( + } + + uint8_t status = {}; +- int16_t group_id = {}; ++ uint16_t group_id = {}; + + + nlohmann::json jsn; +@@ -9416,7 +9416,7 @@ void uic_mqtt_dotdot_on_groups_add_group_if_identifying( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -9480,7 +9480,7 @@ static void uic_mqtt_dotdot_on_generated_groups_add_group_if_identifying( + return; + } + +- int16_t group_id = {}; ++ uint16_t group_id = {}; + std::string group_name; + + +@@ -10549,12 +10549,12 @@ void uic_mqtt_dotdot_on_scenes_add_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; +- int8_t transition_time100ms = {}; ++ uint8_t transition_time100ms = {}; + + + nlohmann::json jsn; +@@ -10634,12 +10634,12 @@ static void uic_mqtt_dotdot_on_generated_scenes_add_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; +- int8_t transition_time100ms = {}; ++ uint8_t transition_time100ms = {}; + + + nlohmann::json jsn; +@@ -10721,8 +10721,8 @@ void uic_mqtt_dotdot_on_scenes_add_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10790,8 +10790,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_add_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10859,8 +10859,8 @@ void uic_mqtt_dotdot_on_scenes_view_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10923,8 +10923,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_view_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -10989,9 +10989,9 @@ void uic_mqtt_dotdot_on_scenes_view_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -11074,9 +11074,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_view_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -11159,8 +11159,8 @@ void uic_mqtt_dotdot_on_scenes_remove_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11223,8 +11223,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11289,8 +11289,8 @@ void uic_mqtt_dotdot_on_scenes_remove_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11358,8 +11358,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11427,7 +11427,7 @@ void uic_mqtt_dotdot_on_scenes_remove_all_scenes( + return; + } + +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -11486,7 +11486,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_all_scenes( + return; + } + +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -11547,7 +11547,7 @@ void uic_mqtt_dotdot_on_scenes_remove_all_scenes_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -11611,7 +11611,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_remove_all_scenes_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -11675,8 +11675,8 @@ void uic_mqtt_dotdot_on_scenes_store_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11739,8 +11739,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_store_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11805,8 +11805,8 @@ void uic_mqtt_dotdot_on_scenes_store_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11874,8 +11874,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_store_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -11943,9 +11943,9 @@ void uic_mqtt_dotdot_on_scenes_recall_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + + + nlohmann::json jsn; +@@ -12012,9 +12012,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_recall_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + + + nlohmann::json jsn; +@@ -12082,7 +12082,7 @@ void uic_mqtt_dotdot_on_scenes_get_scene_membership( + return; + } + +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -12141,7 +12141,7 @@ static void uic_mqtt_dotdot_on_generated_scenes_get_scene_membership( + return; + } + +- uint8_t * groupid = {}; ++ uint16_t groupid = {}; + + + nlohmann::json jsn; +@@ -12202,9 +12202,9 @@ void uic_mqtt_dotdot_on_scenes_get_scene_membership_response( + } + + zclStatus status = {}; +- int8_t capacity = {}; +- uint8_t * groupid = {}; +- std::vector scene_list; ++ uint8_t capacity = {}; ++ uint16_t groupid = {}; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -12277,9 +12277,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_get_scene_membership_response( + } + + zclStatus status = {}; +- int8_t capacity = {}; +- uint8_t * groupid = {}; +- std::vector scene_list; ++ uint8_t capacity = {}; ++ uint16_t groupid = {}; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -12352,9 +12352,9 @@ void uic_mqtt_dotdot_on_scenes_enhanced_add_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12432,9 +12432,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_add_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12514,8 +12514,8 @@ void uic_mqtt_dotdot_on_scenes_enhanced_add_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12583,8 +12583,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_add_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12652,8 +12652,8 @@ void uic_mqtt_dotdot_on_scenes_enhanced_view_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12716,8 +12716,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_view_scene( + return; + } + +- uint8_t * groupid = {}; +- int8_t sceneid = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; + + + nlohmann::json jsn; +@@ -12782,9 +12782,9 @@ void uic_mqtt_dotdot_on_scenes_enhanced_view_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12867,9 +12867,9 @@ static void uic_mqtt_dotdot_on_generated_scenes_enhanced_view_scene_response( + } + + zclStatus status = {}; +- uint8_t * groupid = {}; +- int8_t sceneid = {}; +- int16_t transition_time = {}; ++ uint16_t groupid = {}; ++ uint8_t sceneid = {}; ++ uint16_t transition_time = {}; + std::string scene_name; + std::vector extension_field_sets; + +@@ -12953,10 +12953,10 @@ void uic_mqtt_dotdot_on_scenes_copy_scene( + } + + uint8_t mode = {}; +- uint8_t * group_identifier_from = {}; +- int8_t scene_identifier_from = {}; +- uint8_t * group_identifier_to = {}; +- int8_t scene_identifier_to = {}; ++ uint16_t group_identifier_from = {}; ++ uint8_t scene_identifier_from = {}; ++ uint16_t group_identifier_to = {}; ++ uint8_t scene_identifier_to = {}; + + + nlohmann::json jsn; +@@ -13032,10 +13032,10 @@ static void uic_mqtt_dotdot_on_generated_scenes_copy_scene( + } + + uint8_t mode = {}; +- uint8_t * group_identifier_from = {}; +- int8_t scene_identifier_from = {}; +- uint8_t * group_identifier_to = {}; +- int8_t scene_identifier_to = {}; ++ uint16_t group_identifier_from = {}; ++ uint8_t scene_identifier_from = {}; ++ uint16_t group_identifier_to = {}; ++ uint8_t scene_identifier_to = {}; + + + nlohmann::json jsn; +@@ -13112,8 +13112,8 @@ void uic_mqtt_dotdot_on_scenes_copy_scene_response( + } + + zclStatus status = {}; +- uint8_t * group_identifier_from = {}; +- int8_t scene_identifier_from = {}; ++ uint16_t group_identifier_from = {}; ++ uint8_t scene_identifier_from = {}; + + + nlohmann::json jsn; +@@ -13181,8 +13181,8 @@ static void uic_mqtt_dotdot_on_generated_scenes_copy_scene_response( + } + + zclStatus status = {}; +- uint8_t * group_identifier_from = {}; +- int8_t scene_identifier_from = {}; ++ uint16_t group_identifier_from = {}; ++ uint8_t scene_identifier_from = {}; + + + nlohmann::json jsn; +@@ -13366,7 +13366,7 @@ static void uic_mqtt_dotdot_on_scenes_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_scenes_scene_count_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -13436,7 +13436,7 @@ sl_status_t uic_mqtt_dotdot_scenes_scene_count_unretain( + + sl_status_t uic_mqtt_dotdot_scenes_current_scene_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -13506,7 +13506,7 @@ sl_status_t uic_mqtt_dotdot_scenes_current_scene_unretain( + + sl_status_t uic_mqtt_dotdot_scenes_current_group_publish( + const char *base_topic, +- uint8_t * value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -14623,7 +14623,7 @@ void uic_mqtt_dotdot_on_on_off_off_with_effect( + } + + OffWithEffectEffectIdentifier effect_identifier = {}; +- int8_t effect_variant = {}; ++ uint8_t effect_variant = {}; + + + nlohmann::json jsn; +@@ -14687,7 +14687,7 @@ static void uic_mqtt_dotdot_on_generated_on_off_off_with_effect( + } + + OffWithEffectEffectIdentifier effect_identifier = {}; +- int8_t effect_variant = {}; ++ uint8_t effect_variant = {}; + + + nlohmann::json jsn; +@@ -14855,8 +14855,8 @@ void uic_mqtt_dotdot_on_on_off_on_with_timed_off( + } + + uint8_t on_off_control = {}; +- int16_t on_time = {}; +- int16_t off_wait_time = {}; ++ uint16_t on_time = {}; ++ uint16_t off_wait_time = {}; + + + nlohmann::json jsn; +@@ -14924,8 +14924,8 @@ static void uic_mqtt_dotdot_on_generated_on_off_on_with_timed_off( + } + + uint8_t on_off_control = {}; +- int16_t on_time = {}; +- int16_t off_wait_time = {}; ++ uint16_t on_time = {}; ++ uint16_t off_wait_time = {}; + + + nlohmann::json jsn; +@@ -15245,7 +15245,7 @@ sl_status_t uic_mqtt_dotdot_on_off_global_scene_control_unretain( + + sl_status_t uic_mqtt_dotdot_on_off_on_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -15315,7 +15315,7 @@ sl_status_t uic_mqtt_dotdot_on_off_on_time_unretain( + + sl_status_t uic_mqtt_dotdot_on_off_off_wait_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -15907,8 +15907,8 @@ void uic_mqtt_dotdot_on_level_move_to_level( + return; + } + +- int8_t level = {}; +- int16_t transition_time = {}; ++ uint8_t level = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -15981,8 +15981,8 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_level( + return; + } + +- int8_t level = {}; +- int16_t transition_time = {}; ++ uint8_t level = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16057,7 +16057,7 @@ void uic_mqtt_dotdot_on_level_move( + } + + MoveStepMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16131,7 +16131,7 @@ static void uic_mqtt_dotdot_on_generated_level_move( + } + + MoveStepMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16206,8 +16206,8 @@ void uic_mqtt_dotdot_on_level_step( + } + + MoveStepMode step_mode = {}; +- int8_t step_size = {}; +- int16_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16285,8 +16285,8 @@ static void uic_mqtt_dotdot_on_generated_level_step( + } + + MoveStepMode step_mode = {}; +- int8_t step_size = {}; +- int16_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16493,8 +16493,8 @@ void uic_mqtt_dotdot_on_level_move_to_level_with_on_off( + return; + } + +- int8_t level = {}; +- int16_t transition_time = {}; ++ uint8_t level = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16567,8 +16567,8 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_level_with_on_off( + return; + } + +- int8_t level = {}; +- int16_t transition_time = {}; ++ uint8_t level = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16643,7 +16643,7 @@ void uic_mqtt_dotdot_on_level_move_with_on_off( + } + + MoveStepMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16717,7 +16717,7 @@ static void uic_mqtt_dotdot_on_generated_level_move_with_on_off( + } + + MoveStepMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16792,8 +16792,8 @@ void uic_mqtt_dotdot_on_level_step_with_on_off( + } + + MoveStepMode step_mode = {}; +- int8_t step_size = {}; +- int16_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -16871,8 +16871,8 @@ static void uic_mqtt_dotdot_on_generated_level_step_with_on_off( + } + + MoveStepMode step_mode = {}; +- int8_t step_size = {}; +- int16_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -17079,7 +17079,7 @@ void uic_mqtt_dotdot_on_level_move_to_closest_frequency( + return; + } + +- int16_t frequency = {}; ++ uint16_t frequency = {}; + + + nlohmann::json jsn; +@@ -17138,7 +17138,7 @@ static void uic_mqtt_dotdot_on_generated_level_move_to_closest_frequency( + return; + } + +- int16_t frequency = {}; ++ uint16_t frequency = {}; + + + nlohmann::json jsn; +@@ -17328,7 +17328,7 @@ static void uic_mqtt_dotdot_on_level_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_level_current_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17398,7 +17398,7 @@ sl_status_t uic_mqtt_dotdot_level_current_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_remaining_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17468,7 +17468,7 @@ sl_status_t uic_mqtt_dotdot_level_remaining_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17538,7 +17538,7 @@ sl_status_t uic_mqtt_dotdot_level_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17608,7 +17608,7 @@ sl_status_t uic_mqtt_dotdot_level_max_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_current_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17678,7 +17678,7 @@ sl_status_t uic_mqtt_dotdot_level_current_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_level_min_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17748,7 +17748,7 @@ sl_status_t uic_mqtt_dotdot_level_min_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_level_max_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17887,7 +17887,7 @@ sl_status_t uic_mqtt_dotdot_level_options_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -17957,7 +17957,7 @@ sl_status_t uic_mqtt_dotdot_level_on_off_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18027,7 +18027,7 @@ sl_status_t uic_mqtt_dotdot_level_on_level_unretain( + + sl_status_t uic_mqtt_dotdot_level_on_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18097,7 +18097,7 @@ sl_status_t uic_mqtt_dotdot_level_on_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_off_transition_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18167,7 +18167,7 @@ sl_status_t uic_mqtt_dotdot_level_off_transition_time_unretain( + + sl_status_t uic_mqtt_dotdot_level_default_move_rate_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18237,7 +18237,7 @@ sl_status_t uic_mqtt_dotdot_level_default_move_rate_unretain( + + sl_status_t uic_mqtt_dotdot_level_start_up_current_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -18676,7 +18676,7 @@ void uic_mqtt_dotdot_on_alarms_reset_alarm( + } + + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; ++ uint16_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18740,7 +18740,7 @@ static void uic_mqtt_dotdot_on_generated_alarms_reset_alarm( + } + + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; ++ uint16_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18805,7 +18805,7 @@ void uic_mqtt_dotdot_on_alarms_alarm( + } + + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; ++ uint16_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -18869,7 +18869,7 @@ static void uic_mqtt_dotdot_on_generated_alarms_alarm( + } + + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; ++ uint16_t cluster_identifier = {}; + + + nlohmann::json jsn; +@@ -19038,8 +19038,8 @@ void uic_mqtt_dotdot_on_alarms_get_alarm_response( + + zclStatus status = {}; + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; +- int32_t time_stamp = {}; ++ uint16_t cluster_identifier = {}; ++ uint32_t time_stamp = {}; + + + nlohmann::json jsn; +@@ -19112,8 +19112,8 @@ static void uic_mqtt_dotdot_on_generated_alarms_get_alarm_response( + + zclStatus status = {}; + uint8_t alarm_code = {}; +- uint8_t cluster_identifier = {}; +- int32_t time_stamp = {}; ++ uint16_t cluster_identifier = {}; ++ uint32_t time_stamp = {}; + + + nlohmann::json jsn; +@@ -19495,7 +19495,7 @@ static void uic_mqtt_dotdot_on_alarms_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_alarms_alarm_count_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -19821,7 +19821,7 @@ static void uic_mqtt_dotdot_on_time_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_time_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20030,7 +20030,7 @@ sl_status_t uic_mqtt_dotdot_time_time_zone_unretain( + + sl_status_t uic_mqtt_dotdot_time_dst_start_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20100,7 +20100,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_start_unretain( + + sl_status_t uic_mqtt_dotdot_time_dst_end_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20240,7 +20240,7 @@ sl_status_t uic_mqtt_dotdot_time_dst_shift_unretain( + + sl_status_t uic_mqtt_dotdot_time_standard_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20310,7 +20310,7 @@ sl_status_t uic_mqtt_dotdot_time_standard_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_local_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20380,7 +20380,7 @@ sl_status_t uic_mqtt_dotdot_time_local_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_last_set_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20450,7 +20450,7 @@ sl_status_t uic_mqtt_dotdot_time_last_set_time_unretain( + + sl_status_t uic_mqtt_dotdot_time_valid_until_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -20885,7 +20885,7 @@ void uic_mqtt_dotdot_on_poll_control_check_in_response( + } + + bool start_fast_polling = {}; +- int16_t fast_poll_timeout = {}; ++ uint16_t fast_poll_timeout = {}; + + + nlohmann::json jsn; +@@ -20949,7 +20949,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_check_in_response( + } + + bool start_fast_polling = {}; +- int16_t fast_poll_timeout = {}; ++ uint16_t fast_poll_timeout = {}; + + + nlohmann::json jsn; +@@ -21116,7 +21116,7 @@ void uic_mqtt_dotdot_on_poll_control_set_long_poll_interval( + return; + } + +- int32_t new_long_poll_interval = {}; ++ uint32_t new_long_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21175,7 +21175,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_set_long_poll_interval( + return; + } + +- int32_t new_long_poll_interval = {}; ++ uint32_t new_long_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21235,7 +21235,7 @@ void uic_mqtt_dotdot_on_poll_control_set_short_poll_interval( + return; + } + +- int16_t new_short_poll_interval = {}; ++ uint16_t new_short_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21294,7 +21294,7 @@ static void uic_mqtt_dotdot_on_generated_poll_control_set_short_poll_interval( + return; + } + +- int16_t new_short_poll_interval = {}; ++ uint16_t new_short_poll_interval = {}; + + + nlohmann::json jsn; +@@ -21470,7 +21470,7 @@ static void uic_mqtt_dotdot_on_poll_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21540,7 +21540,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21610,7 +21610,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21680,7 +21680,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_short_poll_interval_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21750,7 +21750,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21820,7 +21820,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_check_in_interval_min_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -21890,7 +21890,7 @@ sl_status_t uic_mqtt_dotdot_poll_control_long_poll_interval_min_unretain( + + sl_status_t uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22198,7 +22198,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22268,7 +22268,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_physical_closed_limit_unretain( + + sl_status_t uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -22407,7 +22407,7 @@ sl_status_t uic_mqtt_dotdot_shade_configuration_status_unretain( + + sl_status_t uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -25590,7 +25590,7 @@ void uic_mqtt_dotdot_on_door_lock_unlock_with_timeout( + return; + } + +- int16_t timeout_in_seconds = {}; ++ uint16_t timeout_in_seconds = {}; + std::string pin_or_rfid_code; + + +@@ -25654,7 +25654,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_unlock_with_timeout( + return; + } + +- int16_t timeout_in_seconds = {}; ++ uint16_t timeout_in_seconds = {}; + std::string pin_or_rfid_code; + + +@@ -25838,7 +25838,7 @@ void uic_mqtt_dotdot_on_door_lock_get_log_record( + return; + } + +- int16_t log_index = {}; ++ uint16_t log_index = {}; + + + nlohmann::json jsn; +@@ -25897,7 +25897,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_log_record( + return; + } + +- int16_t log_index = {}; ++ uint16_t log_index = {}; + + + nlohmann::json jsn; +@@ -25957,12 +25957,12 @@ void uic_mqtt_dotdot_on_door_lock_get_log_record_response( + return; + } + +- int16_t log_entryid = {}; +- int32_t timestamp = {}; ++ uint16_t log_entryid = {}; ++ uint32_t timestamp = {}; + GetLogRecordResponseEventType event_type = {}; + DrlkOperEventSource source_operation_event = {}; +- int8_t event_id_or_alarm_code = {}; +- int16_t userid = {}; ++ uint8_t event_id_or_alarm_code = {}; ++ uint16_t userid = {}; + std::string pin; + + +@@ -26046,12 +26046,12 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_log_record_response( + return; + } + +- int16_t log_entryid = {}; +- int32_t timestamp = {}; ++ uint16_t log_entryid = {}; ++ uint32_t timestamp = {}; + GetLogRecordResponseEventType event_type = {}; + DrlkOperEventSource source_operation_event = {}; +- int8_t event_id_or_alarm_code = {}; +- int16_t userid = {}; ++ uint8_t event_id_or_alarm_code = {}; ++ uint16_t userid = {}; + std::string pin; + + +@@ -26136,7 +26136,7 @@ void uic_mqtt_dotdot_on_door_lock_set_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string pin; +@@ -26210,7 +26210,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string pin; +@@ -26404,7 +26404,7 @@ void uic_mqtt_dotdot_on_door_lock_get_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -26463,7 +26463,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -26523,7 +26523,7 @@ void uic_mqtt_dotdot_on_door_lock_get_pin_code_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string code; +@@ -26597,7 +26597,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_pin_code_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string code; +@@ -26672,7 +26672,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -26731,7 +26731,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_pin_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -27132,7 +27132,7 @@ void uic_mqtt_dotdot_on_door_lock_set_user_status( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + + +@@ -27196,7 +27196,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user_status( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + + +@@ -27380,7 +27380,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_status( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -27439,7 +27439,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_status( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -27499,7 +27499,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_status_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + + +@@ -27563,7 +27563,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_status_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + + +@@ -27628,13 +27628,13 @@ void uic_mqtt_dotdot_on_door_lock_set_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + uint8_t days_mask = {}; +- int8_t start_hour = {}; +- int8_t start_minute = {}; +- int8_t end_hour = {}; +- int8_t end_minute = {}; ++ uint8_t start_hour = {}; ++ uint8_t start_minute = {}; ++ uint8_t end_hour = {}; ++ uint8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -27717,13 +27717,13 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + uint8_t days_mask = {}; +- int8_t start_hour = {}; +- int8_t start_minute = {}; +- int8_t end_hour = {}; +- int8_t end_minute = {}; ++ uint8_t start_hour = {}; ++ uint8_t start_minute = {}; ++ uint8_t end_hour = {}; ++ uint8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -27926,8 +27926,8 @@ void uic_mqtt_dotdot_on_door_lock_get_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -27990,8 +27990,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -28055,14 +28055,14 @@ void uic_mqtt_dotdot_on_door_lock_get_weekday_schedule_response( + return; + } + +- int8_t scheduleid = {}; +- int16_t userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + zclStatus status = {}; + uint8_t days_mask = {}; +- int8_t start_hour = {}; +- int8_t start_minute = {}; +- int8_t end_hour = {}; +- int8_t end_minute = {}; ++ uint8_t start_hour = {}; ++ uint8_t start_minute = {}; ++ uint8_t end_hour = {}; ++ uint8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -28149,14 +28149,14 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_weekday_schedule_response + return; + } + +- int8_t scheduleid = {}; +- int16_t userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + zclStatus status = {}; + uint8_t days_mask = {}; +- int8_t start_hour = {}; +- int8_t start_minute = {}; +- int8_t end_hour = {}; +- int8_t end_minute = {}; ++ uint8_t start_hour = {}; ++ uint8_t start_minute = {}; ++ uint8_t end_hour = {}; ++ uint8_t end_minute = {}; + + + nlohmann::json jsn; +@@ -28244,8 +28244,8 @@ void uic_mqtt_dotdot_on_door_lock_clear_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -28308,8 +28308,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_weekday_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -28492,10 +28492,10 @@ void uic_mqtt_dotdot_on_door_lock_set_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28566,10 +28566,10 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28760,8 +28760,8 @@ void uic_mqtt_dotdot_on_door_lock_get_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -28824,8 +28824,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -28889,11 +28889,11 @@ void uic_mqtt_dotdot_on_door_lock_get_year_day_schedule_response( + return; + } + +- int8_t scheduleid = {}; +- int16_t userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + zclStatus status = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -28968,11 +28968,11 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_year_day_schedule_respons + return; + } + +- int8_t scheduleid = {}; +- int16_t userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + zclStatus status = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + + + nlohmann::json jsn; +@@ -29048,8 +29048,8 @@ void uic_mqtt_dotdot_on_door_lock_clear_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -29112,8 +29112,8 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_year_day_schedule( + return; + } + +- uint8_t * scheduleid = {}; +- uint8_t * userid = {}; ++ uint8_t scheduleid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -29296,9 +29296,9 @@ void uic_mqtt_dotdot_on_door_lock_set_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint8_t holiday_scheduleid = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29370,9 +29370,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint8_t holiday_scheduleid = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29564,7 +29564,7 @@ void uic_mqtt_dotdot_on_door_lock_get_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29623,7 +29623,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29683,10 +29683,10 @@ void uic_mqtt_dotdot_on_door_lock_get_holiday_schedule_response( + return; + } + +- int8_t holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + zclStatus status = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29762,10 +29762,10 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_holiday_schedule_response + return; + } + +- int8_t holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + zclStatus status = {}; +- int32_t local_start_time = {}; +- int32_t local_end_time = {}; ++ uint32_t local_start_time = {}; ++ uint32_t local_end_time = {}; + DrlkOperMode operating_mode_during_holiday = {}; + + +@@ -29842,7 +29842,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -29901,7 +29901,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_holiday_schedule( + return; + } + +- uint8_t * holiday_scheduleid = {}; ++ uint8_t holiday_scheduleid = {}; + + + nlohmann::json jsn; +@@ -30080,7 +30080,7 @@ void uic_mqtt_dotdot_on_door_lock_set_user_type( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30144,7 +30144,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user_type( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30328,7 +30328,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_type( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -30387,7 +30387,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_type( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -30447,7 +30447,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user_type_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30511,7 +30511,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user_type_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserType user_type = {}; + + +@@ -30576,7 +30576,7 @@ void uic_mqtt_dotdot_on_door_lock_set_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -30650,7 +30650,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -30844,7 +30844,7 @@ void uic_mqtt_dotdot_on_door_lock_get_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -30903,7 +30903,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -30963,7 +30963,7 @@ void uic_mqtt_dotdot_on_door_lock_get_rfid_code_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -31037,7 +31037,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_rfid_code_response( + return; + } + +- int16_t userid = {}; ++ uint16_t userid = {}; + DrlkUserStatus user_status = {}; + DrlkUserType user_type = {}; + std::string rfid_code; +@@ -31112,7 +31112,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -31171,7 +31171,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_rfid_code( + return; + } + +- uint8_t * userid = {}; ++ uint16_t userid = {}; + + + nlohmann::json jsn; +@@ -31573,9 +31573,9 @@ void uic_mqtt_dotdot_on_door_lock_set_user( + } + + DataOperationTypeEnum operation_type = {}; +- int16_t user_index = {}; ++ uint16_t user_index = {}; + std::string user_name; +- int32_t user_uniqueid = {}; ++ uint32_t user_uniqueid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + CredentialRuleEnum credential_rule = {}; +@@ -31662,9 +31662,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_user( + } + + DataOperationTypeEnum operation_type = {}; +- int16_t user_index = {}; ++ uint16_t user_index = {}; + std::string user_name; +- int32_t user_uniqueid = {}; ++ uint32_t user_uniqueid = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + CredentialRuleEnum credential_rule = {}; +@@ -31751,7 +31751,7 @@ void uic_mqtt_dotdot_on_door_lock_get_user( + return; + } + +- int16_t user_index = {}; ++ uint16_t user_index = {}; + + + nlohmann::json jsn; +@@ -31810,7 +31810,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_get_user( + return; + } + +- int16_t user_index = {}; ++ uint16_t user_index = {}; + + + nlohmann::json jsn; +@@ -31973,7 +31973,7 @@ void uic_mqtt_dotdot_on_door_lock_clear_user( + return; + } + +- int16_t user_index = {}; ++ uint16_t user_index = {}; + + + nlohmann::json jsn; +@@ -32032,7 +32032,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_clear_user( + return; + } + +- int16_t user_index = {}; ++ uint16_t user_index = {}; + + + nlohmann::json jsn; +@@ -32094,9 +32094,9 @@ void uic_mqtt_dotdot_on_door_lock_operating_event_notification( + + DrlkOperEventSource operation_event_source = {}; + OperatingEventNotificationOperationEventCode operation_event_code = {}; +- int16_t userid = {}; ++ uint16_t userid = {}; + std::string pin; +- int32_t local_time = {}; ++ uint32_t local_time = {}; + std::string data; + + +@@ -32178,9 +32178,9 @@ static void uic_mqtt_dotdot_on_generated_door_lock_operating_event_notification( + + DrlkOperEventSource operation_event_source = {}; + OperatingEventNotificationOperationEventCode operation_event_code = {}; +- int16_t userid = {}; ++ uint16_t userid = {}; + std::string pin; +- int32_t local_time = {}; ++ uint32_t local_time = {}; + std::string data; + + +@@ -32263,11 +32263,11 @@ void uic_mqtt_dotdot_on_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventSource program_event_source = {}; + ProgrammingEventNotificationProgramEventCode program_event_code = {}; +- int16_t userid = {}; ++ uint16_t userid = {}; + std::string pin; + DrlkUserType user_type = {}; + DrlkUserStatus user_status = {}; +- int32_t local_time = {}; ++ uint32_t local_time = {}; + std::string data; + + +@@ -32357,11 +32357,11 @@ static void uic_mqtt_dotdot_on_generated_door_lock_programming_event_notificatio + + ProgrammingEventNotificationProgramEventSource program_event_source = {}; + ProgrammingEventNotificationProgramEventCode program_event_code = {}; +- int16_t userid = {}; ++ uint16_t userid = {}; + std::string pin; + DrlkUserType user_type = {}; + DrlkUserStatus user_status = {}; +- int32_t local_time = {}; ++ uint32_t local_time = {}; + std::string data; + + +@@ -32453,7 +32453,7 @@ void uic_mqtt_dotdot_on_door_lock_set_credential( + DataOperationTypeEnum operation_type = {}; + CredentialStruct credential = {}; + std::string credential_data; +- int16_t user_index = {}; ++ uint16_t user_index = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + +@@ -32537,7 +32537,7 @@ static void uic_mqtt_dotdot_on_generated_door_lock_set_credential( + DataOperationTypeEnum operation_type = {}; + CredentialStruct credential = {}; + std::string credential_data; +- int16_t user_index = {}; ++ uint16_t user_index = {}; + DrlkSettableUserStatus user_status = {}; + DrlkUserType user_type = {}; + +@@ -33669,7 +33669,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_state_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33739,7 +33739,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33809,7 +33809,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_door_closed_events_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_open_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33879,7 +33879,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_open_period_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -33949,7 +33949,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_log_records_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34019,7 +34019,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_total_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34089,7 +34089,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34159,7 +34159,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34229,7 +34229,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34299,7 +34299,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34369,7 +34369,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_unre + + sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34439,7 +34439,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_pin_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34509,7 +34509,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_min_pin_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34579,7 +34579,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_max_rfid_code_length_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34718,7 +34718,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_credential_rules_support_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34924,7 +34924,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_language_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_led_settings_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -34994,7 +34994,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_led_settings_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35064,7 +35064,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_auto_relock_time_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_sound_volume_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35694,7 +35694,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_local_programming_features_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -35764,7 +35764,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -36047,7 +36047,7 @@ sl_status_t uic_mqtt_dotdot_door_lock_security_level_unretain( + + sl_status_t uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -37890,7 +37890,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_lift_value( + return; + } + +- int16_t lift_value = {}; ++ uint16_t lift_value = {}; + + + nlohmann::json jsn; +@@ -37949,7 +37949,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_lift_value( + return; + } + +- int16_t lift_value = {}; ++ uint16_t lift_value = {}; + + + nlohmann::json jsn; +@@ -38009,7 +38009,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_lift_percentage( + return; + } + +- int8_t percentage_lift_value = {}; ++ uint8_t percentage_lift_value = {}; + + + nlohmann::json jsn; +@@ -38068,7 +38068,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_lift_percentage( + return; + } + +- int8_t percentage_lift_value = {}; ++ uint8_t percentage_lift_value = {}; + + + nlohmann::json jsn; +@@ -38128,7 +38128,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_tilt_value( + return; + } + +- int16_t tilt_value = {}; ++ uint16_t tilt_value = {}; + + + nlohmann::json jsn; +@@ -38187,7 +38187,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_tilt_value( + return; + } + +- int16_t tilt_value = {}; ++ uint16_t tilt_value = {}; + + + nlohmann::json jsn; +@@ -38247,7 +38247,7 @@ void uic_mqtt_dotdot_on_window_covering_go_to_tilt_percentage( + return; + } + +- int8_t percentage_tilt_value = {}; ++ uint8_t percentage_tilt_value = {}; + + + nlohmann::json jsn; +@@ -38306,7 +38306,7 @@ static void uic_mqtt_dotdot_on_generated_window_covering_go_to_tilt_percentage( + return; + } + +- int8_t percentage_tilt_value = {}; ++ uint8_t percentage_tilt_value = {}; + + + nlohmann::json jsn; +@@ -38581,7 +38581,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_window_covering_type_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38651,7 +38651,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38721,7 +38721,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38791,7 +38791,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38861,7 +38861,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -38931,7 +38931,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39070,7 +39070,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_config_or_status_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39140,7 +39140,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_lift_percentage_unr + + sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39210,7 +39210,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_unr + + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39280,7 +39280,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39350,7 +39350,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39420,7 +39420,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39490,7 +39490,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39560,7 +39560,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_velocity_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39630,7 +39630,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_acceleration_time_lift_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39769,7 +39769,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_mode_unretain( + + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -39835,7 +39835,7 @@ sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_unretain + + sl_status_t uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + const char *base_topic, +- uint8_t value, ++ const char* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40113,7 +40113,7 @@ void uic_mqtt_dotdot_on_barrier_control_go_to_percent( + return; + } + +- int8_t percent_open = {}; ++ uint8_t percent_open = {}; + + + nlohmann::json jsn; +@@ -40172,7 +40172,7 @@ static void uic_mqtt_dotdot_on_generated_barrier_control_go_to_percent( + return; + } + +- int8_t percent_open = {}; ++ uint8_t percent_open = {}; + + + nlohmann::json jsn; +@@ -40668,7 +40668,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_capabilities_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_open_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40738,7 +40738,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_close_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40808,7 +40808,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40878,7 +40878,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_open_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -40948,7 +40948,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_command_close_events_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_open_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41018,7 +41018,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_open_period_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_close_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41088,7 +41088,7 @@ sl_status_t uic_mqtt_dotdot_barrier_control_close_period_unretain( + + sl_status_t uic_mqtt_dotdot_barrier_control_barrier_position_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41480,7 +41480,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_pressure_unretain + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41550,7 +41550,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_speed_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41900,7 +41900,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_comp_pressure_unr + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -41970,7 +41970,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_unret + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42040,7 +42040,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_unret + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42110,7 +42110,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_unreta + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42605,7 +42605,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_capacity_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42675,7 +42675,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_speed_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42745,7 +42745,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hour + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -42815,7 +42815,7 @@ sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_power_unretain( + + sl_status_t uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -43862,12 +43862,12 @@ void uic_mqtt_dotdot_on_thermostat_get_relay_status_log_response( + return; + } + +- int16_t time_of_day = {}; ++ uint16_t time_of_day = {}; + uint8_t relay_status = {}; + int16_t local_temperature = {}; +- int8_t humidity_percentage = {}; ++ uint8_t humidity_percentage = {}; + int16_t set_point = {}; +- int16_t unread_entries = {}; ++ uint16_t unread_entries = {}; + + + nlohmann::json jsn; +@@ -43946,12 +43946,12 @@ static void uic_mqtt_dotdot_on_generated_thermostat_get_relay_status_log_respons + return; + } + +- int16_t time_of_day = {}; ++ uint16_t time_of_day = {}; + uint8_t relay_status = {}; + int16_t local_temperature = {}; +- int8_t humidity_percentage = {}; ++ uint8_t humidity_percentage = {}; + int16_t set_point = {}; +- int16_t unread_entries = {}; ++ uint16_t unread_entries = {}; + + + nlohmann::json jsn; +@@ -45057,7 +45057,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_abs_max_cool_setpoint_limit_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -45127,7 +45127,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_pi_cooling_demand_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46396,7 +46396,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_start_of_week_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46466,7 +46466,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46609,7 +46609,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -46960,7 +46960,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_amount_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47030,7 +47030,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_unretain + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47100,7 +47100,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47170,7 +47170,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_min_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47240,7 +47240,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_occupied_setback_max_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47310,7 +47310,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47380,7 +47380,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_min_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47450,7 +47450,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_unoccupied_setback_max_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -47593,7 +47593,7 @@ sl_status_t uic_mqtt_dotdot_thermostat_ac_type_unretain( + + sl_status_t uic_mqtt_dotdot_thermostat_ac_capacity_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48692,7 +48692,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48762,7 +48762,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_relative_humidity_unretain( + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -48832,7 +48832,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_un + + sl_status_t uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -49048,7 +49048,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_lockout_un + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -49118,7 +49118,7 @@ sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis + + sl_status_t uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -50425,9 +50425,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_hue( + return; + } + +- int8_t hue = {}; ++ uint8_t hue = {}; + CCDirection direction = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50504,9 +50504,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_hue( + return; + } + +- int8_t hue = {}; ++ uint8_t hue = {}; + CCDirection direction = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50585,7 +50585,7 @@ void uic_mqtt_dotdot_on_color_control_move_hue( + } + + CCMoveMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50659,7 +50659,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_hue( + } + + CCMoveMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50734,8 +50734,8 @@ void uic_mqtt_dotdot_on_color_control_step_hue( + } + + CCStepMode step_mode = {}; +- int8_t step_size = {}; +- int8_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50813,8 +50813,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_hue( + } + + CCStepMode step_mode = {}; +- int8_t step_size = {}; +- int8_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50892,8 +50892,8 @@ void uic_mqtt_dotdot_on_color_control_move_to_saturation( + return; + } + +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -50966,8 +50966,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_saturation( + return; + } + +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51042,7 +51042,7 @@ void uic_mqtt_dotdot_on_color_control_move_saturation( + } + + CCMoveMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51116,7 +51116,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_saturation( + } + + CCMoveMode move_mode = {}; +- int8_t rate = {}; ++ uint8_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51191,8 +51191,8 @@ void uic_mqtt_dotdot_on_color_control_step_saturation( + } + + CCStepMode step_mode = {}; +- int8_t step_size = {}; +- int8_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51270,8 +51270,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_saturation( + } + + CCStepMode step_mode = {}; +- int8_t step_size = {}; +- int8_t transition_time = {}; ++ uint8_t step_size = {}; ++ uint8_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51349,9 +51349,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_hue_and_saturation( + return; + } + +- int8_t hue = {}; +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint8_t hue = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51428,9 +51428,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_hue_and_saturatio + return; + } + +- int8_t hue = {}; +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint8_t hue = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51508,9 +51508,9 @@ void uic_mqtt_dotdot_on_color_control_move_to_color( + return; + } + +- int16_t colorx = {}; +- int16_t colory = {}; +- int16_t transition_time = {}; ++ uint16_t colorx = {}; ++ uint16_t colory = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51587,9 +51587,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_color( + return; + } + +- int16_t colorx = {}; +- int16_t colory = {}; +- int16_t transition_time = {}; ++ uint16_t colorx = {}; ++ uint16_t colory = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51818,7 +51818,7 @@ void uic_mqtt_dotdot_on_color_control_step_color( + + int16_t stepx = {}; + int16_t stepy = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51897,7 +51897,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_color( + + int16_t stepx = {}; + int16_t stepy = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -51975,8 +51975,8 @@ void uic_mqtt_dotdot_on_color_control_move_to_color_temperature( + return; + } + +- int16_t color_temperature_mireds = {}; +- int16_t transition_time = {}; ++ uint16_t color_temperature_mireds = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52049,8 +52049,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_to_color_temperature + return; + } + +- int16_t color_temperature_mireds = {}; +- int16_t transition_time = {}; ++ uint16_t color_temperature_mireds = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52124,9 +52124,9 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_to_hue( + return; + } + +- int16_t enhanced_hue = {}; ++ uint16_t enhanced_hue = {}; + CCDirection direction = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52203,9 +52203,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_to_hue( + return; + } + +- int16_t enhanced_hue = {}; ++ uint16_t enhanced_hue = {}; + CCDirection direction = {}; +- int16_t transition_time = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52284,7 +52284,7 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_hue( + } + + CCMoveMode move_mode = {}; +- int16_t rate = {}; ++ uint16_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52358,7 +52358,7 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_hue( + } + + CCMoveMode move_mode = {}; +- int16_t rate = {}; ++ uint16_t rate = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52433,8 +52433,8 @@ void uic_mqtt_dotdot_on_color_control_enhanced_step_hue( + } + + CCStepMode step_mode = {}; +- int16_t step_size = {}; +- int16_t transition_time = {}; ++ uint16_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52512,8 +52512,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_step_hue( + } + + CCStepMode step_mode = {}; +- int16_t step_size = {}; +- int16_t transition_time = {}; ++ uint16_t step_size = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52591,9 +52591,9 @@ void uic_mqtt_dotdot_on_color_control_enhanced_move_to_hue_and_saturation( + return; + } + +- int16_t enhanced_hue = {}; +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint16_t enhanced_hue = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52670,9 +52670,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_enhanced_move_to_hue_and_ + return; + } + +- int16_t enhanced_hue = {}; +- int8_t saturation = {}; +- int16_t transition_time = {}; ++ uint16_t enhanced_hue = {}; ++ uint8_t saturation = {}; ++ uint16_t transition_time = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52753,8 +52753,8 @@ void uic_mqtt_dotdot_on_color_control_color_loop_set( + uint8_t update_flags = {}; + ColorLoopSetAction action = {}; + CCColorLoopDirection direction = {}; +- int16_t time = {}; +- int16_t start_hue = {}; ++ uint16_t time = {}; ++ uint16_t start_hue = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -52842,8 +52842,8 @@ static void uic_mqtt_dotdot_on_generated_color_control_color_loop_set( + uint8_t update_flags = {}; + ColorLoopSetAction action = {}; + CCColorLoopDirection direction = {}; +- int16_t time = {}; +- int16_t start_hue = {}; ++ uint16_t time = {}; ++ uint16_t start_hue = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53059,9 +53059,9 @@ void uic_mqtt_dotdot_on_color_control_move_color_temperature( + } + + CCMoveMode move_mode = {}; +- int16_t rate = {}; +- uint8_t * color_temperature_minimum_mireds = {}; +- uint8_t * color_temperature_maximum_mireds = {}; ++ uint16_t rate = {}; ++ uint16_t color_temperature_minimum_mireds = {}; ++ uint16_t color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53143,9 +53143,9 @@ static void uic_mqtt_dotdot_on_generated_color_control_move_color_temperature( + } + + CCMoveMode move_mode = {}; +- int16_t rate = {}; +- uint8_t * color_temperature_minimum_mireds = {}; +- uint8_t * color_temperature_maximum_mireds = {}; ++ uint16_t rate = {}; ++ uint16_t color_temperature_minimum_mireds = {}; ++ uint16_t color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53228,10 +53228,10 @@ void uic_mqtt_dotdot_on_color_control_step_color_temperature( + } + + CCStepMode step_mode = {}; +- int16_t step_size = {}; +- int16_t transition_time = {}; +- uint8_t * color_temperature_minimum_mireds = {}; +- uint8_t * color_temperature_maximum_mireds = {}; ++ uint16_t step_size = {}; ++ uint16_t transition_time = {}; ++ uint16_t color_temperature_minimum_mireds = {}; ++ uint16_t color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53317,10 +53317,10 @@ static void uic_mqtt_dotdot_on_generated_color_control_step_color_temperature( + } + + CCStepMode step_mode = {}; +- int16_t step_size = {}; +- int16_t transition_time = {}; +- uint8_t * color_temperature_minimum_mireds = {}; +- uint8_t * color_temperature_maximum_mireds = {}; ++ uint16_t step_size = {}; ++ uint16_t transition_time = {}; ++ uint16_t color_temperature_minimum_mireds = {}; ++ uint16_t color_temperature_maximum_mireds = {}; + uint8_t options_mask = {}; + uint8_t options_override = {}; + +@@ -53612,7 +53612,7 @@ static void uic_mqtt_dotdot_on_color_control_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_color_control_current_hue_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53682,7 +53682,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_hue_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_current_saturation_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53752,7 +53752,7 @@ sl_status_t uic_mqtt_dotdot_color_control_current_saturation_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_remaining_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53822,7 +53822,7 @@ sl_status_t uic_mqtt_dotdot_color_control_remaining_time_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_currentx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -53892,7 +53892,7 @@ sl_status_t uic_mqtt_dotdot_color_control_currentx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_currenty_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54101,7 +54101,7 @@ sl_status_t uic_mqtt_dotdot_color_control_compensation_text_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54313,7 +54313,7 @@ sl_status_t uic_mqtt_dotdot_color_control_options_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54383,7 +54383,7 @@ sl_status_t uic_mqtt_dotdot_color_control_number_of_primaries_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54453,7 +54453,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54523,7 +54523,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54593,7 +54593,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary1_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54663,7 +54663,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54733,7 +54733,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54803,7 +54803,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary2_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54873,7 +54873,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -54943,7 +54943,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55013,7 +55013,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary3_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55083,7 +55083,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55153,7 +55153,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55223,7 +55223,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary4_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55293,7 +55293,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55363,7 +55363,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55433,7 +55433,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary5_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6x_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55503,7 +55503,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6x_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6y_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55573,7 +55573,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6y_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55643,7 +55643,7 @@ sl_status_t uic_mqtt_dotdot_color_control_primary6_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_white_pointx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55713,7 +55713,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_white_pointy_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55783,7 +55783,7 @@ sl_status_t uic_mqtt_dotdot_color_control_white_pointy_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55853,7 +55853,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointrx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55923,7 +55923,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointry_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -55993,7 +55993,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointr_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56063,7 +56063,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56133,7 +56133,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointgy_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56203,7 +56203,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointg_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56273,7 +56273,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointbx_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointby_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56343,7 +56343,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointby_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56413,7 +56413,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_pointb_intensity_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56556,7 +56556,7 @@ sl_status_t uic_mqtt_dotdot_color_control_enhanced_color_mode_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56626,7 +56626,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_active_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56696,7 +56696,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_direction_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56766,7 +56766,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_time_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56836,7 +56836,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_unretain + + sl_status_t uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -56975,7 +56975,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_capabilities_unretain( + + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57045,7 +57045,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_unretai + + sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57115,7 +57115,7 @@ sl_status_t uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_unretai + + sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57185,7 +57185,7 @@ sl_status_t uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_ + + sl_status_t uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57627,7 +57627,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57697,7 +57697,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57836,7 +57836,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_status_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57906,7 +57906,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_min_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -57976,7 +57976,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_max_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58046,7 +58046,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_level_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58116,7 +58116,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58186,7 +58186,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_unret + + sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58256,7 +58256,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_unre + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58458,7 +58458,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_manufacturer_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58528,7 +58528,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58667,7 +58667,7 @@ sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_alarm_mode_unretain( + + sl_status_t uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -58935,7 +58935,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59005,7 +59005,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59075,7 +59075,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59145,7 +59145,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -59628,7 +59628,7 @@ sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_light_sensor_type_unretain + + sl_status_t uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60104,7 +60104,7 @@ sl_status_t uic_mqtt_dotdot_temperature_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60590,7 +60590,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -60870,7 +60870,7 @@ sl_status_t uic_mqtt_dotdot_pressure_measurement_max_scaled_value_unretain( + + sl_status_t uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61206,7 +61206,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61276,7 +61276,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61346,7 +61346,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61416,7 +61416,7 @@ sl_status_t uic_mqtt_dotdot_flow_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_flow_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61682,7 +61682,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61752,7 +61752,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61822,7 +61822,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -61892,7 +61892,7 @@ sl_status_t uic_mqtt_dotdot_relativity_humidity_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62385,7 +62385,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_occupancy_sensor_type_bitmap_unret + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62455,7 +62455,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_u + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62525,7 +62525,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_u + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62595,7 +62595,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_thresho + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62665,7 +62665,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62735,7 +62735,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62805,7 +62805,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62875,7 +62875,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unocc + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -62945,7 +62945,7 @@ sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occ + + sl_status_t uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63211,7 +63211,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63281,7 +63281,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63351,7 +63351,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63421,7 +63421,7 @@ sl_status_t uic_mqtt_dotdot_soil_moisture_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_soil_moisture_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63687,7 +63687,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63757,7 +63757,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63827,7 +63827,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -63897,7 +63897,7 @@ sl_status_t uic_mqtt_dotdot_ph_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_ph_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64163,7 +64163,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_force_read_at + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64233,7 +64233,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_u + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64303,7 +64303,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_val + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64373,7 +64373,7 @@ sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_val + + sl_status_t uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64639,7 +64639,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64709,7 +64709,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64779,7 +64779,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -64849,7 +64849,7 @@ sl_status_t uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_unretain( + + sl_status_t uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -66609,7 +66609,7 @@ void uic_mqtt_dotdot_on_ias_zone_zone_enroll_response( + } + + ZoneEnrollResponseEnrollResponseCode enroll_response_code = {}; +- int8_t zoneid = {}; ++ uint8_t zoneid = {}; + + + nlohmann::json jsn; +@@ -66673,7 +66673,7 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_enroll_response( + } + + ZoneEnrollResponseEnrollResponseCode enroll_response_code = {}; +- int8_t zoneid = {}; ++ uint8_t zoneid = {}; + + + nlohmann::json jsn; +@@ -66739,8 +66739,8 @@ void uic_mqtt_dotdot_on_ias_zone_zone_status_change_notification( + + uint16_t zone_status = {}; + uint8_t extended_status = {}; +- int8_t zoneid = {}; +- int16_t delay = {}; ++ uint8_t zoneid = {}; ++ uint16_t delay = {}; + + + nlohmann::json jsn; +@@ -66813,8 +66813,8 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_status_change_notificatio + + uint16_t zone_status = {}; + uint8_t extended_status = {}; +- int8_t zoneid = {}; +- int16_t delay = {}; ++ uint8_t zoneid = {}; ++ uint16_t delay = {}; + + + nlohmann::json jsn; +@@ -66990,7 +66990,7 @@ void uic_mqtt_dotdot_on_ias_zone_zone_enroll_request( + } + + IasZoneType zone_type = {}; +- int16_t manufacturer_code = {}; ++ uint16_t manufacturer_code = {}; + + + nlohmann::json jsn; +@@ -67054,7 +67054,7 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_zone_enroll_request( + } + + IasZoneType zone_type = {}; +- int16_t manufacturer_code = {}; ++ uint16_t manufacturer_code = {}; + + + nlohmann::json jsn; +@@ -67118,8 +67118,8 @@ void uic_mqtt_dotdot_on_ias_zone_initiate_test_mode( + return; + } + +- int8_t test_mode_duration = {}; +- int8_t current_zone_sensitivity_level = {}; ++ uint8_t test_mode_duration = {}; ++ uint8_t current_zone_sensitivity_level = {}; + + + nlohmann::json jsn; +@@ -67182,8 +67182,8 @@ static void uic_mqtt_dotdot_on_generated_ias_zone_initiate_test_mode( + return; + } + +- int8_t test_mode_duration = {}; +- int8_t current_zone_sensitivity_level = {}; ++ uint8_t test_mode_duration = {}; ++ uint8_t current_zone_sensitivity_level = {}; + + + nlohmann::json jsn; +@@ -67648,7 +67648,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_iascie_address_unretain( + + sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -67718,7 +67718,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_zoneid_unretain( + + sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -67788,7 +67788,7 @@ sl_status_t uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported + + sl_status_t uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68055,8 +68055,8 @@ void uic_mqtt_dotdot_on_iaswd_start_warning( + } + + uint8_t siren_configuration = {}; +- int16_t warning_duration = {}; +- int8_t strobe_duty_cycle = {}; ++ uint16_t warning_duration = {}; ++ uint8_t strobe_duty_cycle = {}; + IaswdLevel strobe_level = {}; + + +@@ -68129,8 +68129,8 @@ static void uic_mqtt_dotdot_on_generated_iaswd_start_warning( + } + + uint8_t siren_configuration = {}; +- int16_t warning_duration = {}; +- int8_t strobe_duty_cycle = {}; ++ uint16_t warning_duration = {}; ++ uint8_t strobe_duty_cycle = {}; + IaswdLevel strobe_level = {}; + + +@@ -68426,7 +68426,7 @@ static void uic_mqtt_dotdot_on_iaswd_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_iaswd_max_duration_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68752,7 +68752,7 @@ static void uic_mqtt_dotdot_on_metering_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68822,7 +68822,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_delivered_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_summation_received_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -68892,7 +68892,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_summation_received_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69102,7 +69102,7 @@ sl_status_t uic_mqtt_dotdot_metering_power_factor_unretain( + + sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69172,7 +69172,7 @@ sl_status_t uic_mqtt_dotdot_metering_reading_snap_shot_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69242,7 +69242,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_delivered_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + const char *base_topic, +- uint8_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69312,7 +69312,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_max_demand_received_time_unretain( + + sl_status_t uic_mqtt_dotdot_metering_default_update_period_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69455,7 +69455,7 @@ sl_status_t uic_mqtt_dotdot_metering_supply_status_unretain( + + sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69525,7 +69525,7 @@ sl_status_t uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_unre + + sl_status_t uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69808,7 +69808,7 @@ sl_status_t uic_mqtt_dotdot_metering_unitof_measure_unretain( + + sl_status_t uic_mqtt_dotdot_metering_multiplier_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -69878,7 +69878,7 @@ sl_status_t uic_mqtt_dotdot_metering_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_metering_divisor_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -70807,10 +70807,10 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_profile_info_response( + return; + } + +- int8_t profile_count = {}; ++ uint8_t profile_count = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- int8_t max_number_of_intervals = {}; +- std::vector list_of_attributes; ++ uint8_t max_number_of_intervals = {}; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -70882,10 +70882,10 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_profile_info + return; + } + +- int8_t profile_count = {}; ++ uint8_t profile_count = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- int8_t max_number_of_intervals = {}; +- std::vector list_of_attributes; ++ uint8_t max_number_of_intervals = {}; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -71061,12 +71061,12 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_measurement_profile_response( + return; + } + +- uint8_t start_time = {}; ++ uint32_t start_time = {}; + GetMeasurementProfileResponseStatus status = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- int8_t number_of_intervals_delivered = {}; +- uint8_t attribute_id = {}; +- std::vector intervals; ++ uint8_t number_of_intervals_delivered = {}; ++ uint16_t attribute_id = {}; ++ std::vector intervals; + + + nlohmann::json jsn; +@@ -71146,12 +71146,12 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_measurement_ + return; + } + +- uint8_t start_time = {}; ++ uint32_t start_time = {}; + GetMeasurementProfileResponseStatus status = {}; + ProfileIntervalPeriod profile_interval_period = {}; +- int8_t number_of_intervals_delivered = {}; +- uint8_t attribute_id = {}; +- std::vector intervals; ++ uint8_t number_of_intervals_delivered = {}; ++ uint16_t attribute_id = {}; ++ std::vector intervals; + + + nlohmann::json jsn; +@@ -71232,9 +71232,9 @@ void uic_mqtt_dotdot_on_electrical_measurement_get_measurement_profile( + return; + } + +- uint8_t attributeid = {}; +- uint8_t start_time = {}; +- int8_t number_of_intervals = {}; ++ uint16_t attributeid = {}; ++ uint32_t start_time = {}; ++ uint8_t number_of_intervals = {}; + + + nlohmann::json jsn; +@@ -71301,9 +71301,9 @@ static void uic_mqtt_dotdot_on_generated_electrical_measurement_get_measurement_ + return; + } + +- uint8_t attributeid = {}; +- uint8_t start_time = {}; +- int8_t number_of_intervals = {}; ++ uint16_t attributeid = {}; ++ uint32_t start_time = {}; ++ uint8_t number_of_intervals = {}; + + + nlohmann::json jsn; +@@ -72426,7 +72426,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72496,7 +72496,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72566,7 +72566,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72636,7 +72636,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72706,7 +72706,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72776,7 +72776,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72846,7 +72846,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72916,7 +72916,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -72986,7 +72986,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -73056,7 +73056,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -73266,7 +73266,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_total_reactive_power_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74176,7 +74176,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_measured_phase11th_harmonic_c + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74246,7 +74246,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_unret + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74316,7 +74316,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74386,7 +74386,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74596,7 +74596,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_phase_harmonic_current_multip + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74806,7 +74806,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74876,7 +74876,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -74946,7 +74946,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75016,7 +75016,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75086,7 +75086,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75156,7 +75156,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75506,7 +75506,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75646,7 +75646,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75716,7 +75716,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75786,7 +75786,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75856,7 +75856,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75926,7 +75926,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -75996,7 +75996,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76066,7 +76066,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_unreta + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76136,7 +76136,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_unre + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76206,7 +76206,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76276,7 +76276,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76346,7 +76346,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_unretai + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76416,7 +76416,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -76486,7 +76486,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77534,7 +77534,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77744,7 +77744,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phb_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77814,7 +77814,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77884,7 +77884,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -77954,7 +77954,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78024,7 +78024,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78094,7 +78094,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78444,7 +78444,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78584,7 +78584,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phb_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78654,7 +78654,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78724,7 +78724,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78794,7 +78794,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78864,7 +78864,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -78934,7 +78934,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79004,7 +79004,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_un + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79074,7 +79074,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_ + + sl_status_t uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79284,7 +79284,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_current_phc_unretain + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79354,7 +79354,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79424,7 +79424,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79494,7 +79494,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79564,7 +79564,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79634,7 +79634,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -79984,7 +79984,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_reactive_power_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80124,7 +80124,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_power_factor_phc_unretain( + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80194,7 +80194,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measureme + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80264,7 +80264,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_coun + + sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80334,7 +80334,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_cou + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80404,7 +80404,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_peri + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80474,7 +80474,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_per + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80544,7 +80544,7 @@ sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_un + + sl_status_t uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80898,7 +80898,7 @@ static void uic_mqtt_dotdot_on_diagnostics_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -80968,7 +80968,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_number_of_resets_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81038,7 +81038,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_persistent_memory_writes_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81108,7 +81108,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81178,7 +81178,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81248,7 +81248,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_rx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81318,7 +81318,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81388,7 +81388,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81458,7 +81458,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81528,7 +81528,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81598,7 +81598,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_bcast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81668,7 +81668,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_rx_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81738,7 +81738,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81808,7 +81808,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81878,7 +81878,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -81948,7 +81948,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_route_disc_initiated_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82018,7 +82018,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_added_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82088,7 +82088,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_removed_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82158,7 +82158,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_neighbor_stale_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82228,7 +82228,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_join_indication_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82298,7 +82298,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_child_moved_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82368,7 +82368,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwkfc_failure_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82438,7 +82438,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_apsfc_failure_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82508,7 +82508,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82578,7 +82578,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82648,7 +82648,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82718,7 +82718,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_unretain + + sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82788,7 +82788,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_relayed_ucast_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82858,7 +82858,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82928,7 +82928,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_unretain( + + sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -82998,7 +82998,7 @@ sl_status_t uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_u + + sl_status_t uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -83262,17 +83262,17 @@ void uic_mqtt_dotdot_on_protocol_controller_rf_telemetry_tx_report( + std::string sourceunid; + std::string destinationunid; + bool transmission_successful = {}; +- int16_t transmission_time_ms = {}; ++ uint16_t transmission_time_ms = {}; + int8_t tx_powerd_bm = {}; +- int8_t tx_channel = {}; +- int8_t routing_attempts = {}; ++ uint8_t tx_channel = {}; ++ uint8_t routing_attempts = {}; + bool route_changed = {}; + TxReportTransmissionSpeed transmission_speed = {}; + int8_t measured_noise_floord_bm = {}; + std::vector last_route_repeaters; + std::vector incoming_rssi_repeaters; + int8_t ackrssi = {}; +- int8_t ack_channel = {}; ++ uint8_t ack_channel = {}; + std::string last_route_failed_link_functionalunid; + std::string last_route_failed_link_non_functionalunid; + int8_t destination_ack_tx_powerd_bm = {}; +@@ -83419,17 +83419,17 @@ static void uic_mqtt_dotdot_on_generated_protocol_controller_rf_telemetry_tx_rep + std::string sourceunid; + std::string destinationunid; + bool transmission_successful = {}; +- int16_t transmission_time_ms = {}; ++ uint16_t transmission_time_ms = {}; + int8_t tx_powerd_bm = {}; +- int8_t tx_channel = {}; +- int8_t routing_attempts = {}; ++ uint8_t tx_channel = {}; ++ uint8_t routing_attempts = {}; + bool route_changed = {}; + TxReportTransmissionSpeed transmission_speed = {}; + int8_t measured_noise_floord_bm = {}; + std::vector last_route_repeaters; + std::vector incoming_rssi_repeaters; + int8_t ackrssi = {}; +- int8_t ack_channel = {}; ++ uint8_t ack_channel = {}; + std::string last_route_failed_link_functionalunid; + std::string last_route_failed_link_non_functionalunid; + int8_t destination_ack_tx_powerd_bm = {}; +@@ -84854,7 +84854,7 @@ static void uic_mqtt_dotdot_on_state_force_read_attributes( + sl_status_t uic_mqtt_dotdot_state_endpoint_id_list_publish( + const char *base_topic, + size_t value_count, +- const int8_t* value, ++ const uint8_t* value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -85071,7 +85071,7 @@ sl_status_t uic_mqtt_dotdot_state_security_unretain( + + sl_status_t uic_mqtt_dotdot_state_maximum_command_delay_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -85489,7 +85489,7 @@ void uic_mqtt_dotdot_on_binding_bind( + + std::string cluster_name; + std::string destination_unid; +- int8_t destination_ep = {}; ++ uint8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85558,7 +85558,7 @@ static void uic_mqtt_dotdot_on_generated_binding_bind( + + std::string cluster_name; + std::string destination_unid; +- int8_t destination_ep = {}; ++ uint8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85628,7 +85628,7 @@ void uic_mqtt_dotdot_on_binding_unbind( + + std::string cluster_name; + std::string destination_unid; +- int8_t destination_ep = {}; ++ uint8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -85697,7 +85697,7 @@ static void uic_mqtt_dotdot_on_generated_binding_unbind( + + std::string cluster_name; + std::string destination_unid; +- int8_t destination_ep = {}; ++ uint8_t destination_ep = {}; + + + nlohmann::json jsn; +@@ -86605,7 +86605,7 @@ static void uic_mqtt_dotdot_on_system_metrics_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -87972,7 +87972,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_fqdn_unretain( + + sl_status_t uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -88462,7 +88462,7 @@ sl_status_t uic_mqtt_dotdot_system_metrics_battery_percentage_unretain( + + sl_status_t uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89224,7 +89224,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_application_mqtt_topics_unret + + sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89294,7 +89294,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_uptime_minutes_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_process_id_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89639,7 +89639,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_logging_level_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89709,7 +89709,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_int + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89779,7 +89779,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_unretain( + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -89849,7 +89849,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_unreta + + sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + const char *base_topic, +- int64_t value, ++ uint64_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -90129,7 +90129,7 @@ sl_status_t uic_mqtt_dotdot_application_monitoring_mqtt_max_delivery_time_second + + sl_status_t uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + const char *base_topic, +- int32_t value, ++ uint32_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -91106,7 +91106,7 @@ void uic_mqtt_dotdot_on_configuration_parameters_discover_parameter( + return; + } + +- int16_t parameter_id = {}; ++ uint16_t parameter_id = {}; + + + nlohmann::json jsn; +@@ -91165,7 +91165,7 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_discover_param + return; + } + +- int16_t parameter_id = {}; ++ uint16_t parameter_id = {}; + + + nlohmann::json jsn; +@@ -91328,7 +91328,7 @@ void uic_mqtt_dotdot_on_configuration_parameters_set_parameter( + return; + } + +- int16_t parameter_id = {}; ++ uint16_t parameter_id = {}; + int64_t value = {}; + + +@@ -91392,7 +91392,7 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_set_parameter( + return; + } + +- int16_t parameter_id = {}; ++ uint16_t parameter_id = {}; + int64_t value = {}; + + +@@ -91457,8 +91457,8 @@ void uic_mqtt_dotdot_on_configuration_parameters_discover_parameter_range( + return; + } + +- int16_t first_parameter_id = {}; +- int16_t last_parameter_id = {}; ++ uint16_t first_parameter_id = {}; ++ uint16_t last_parameter_id = {}; + + + nlohmann::json jsn; +@@ -91521,8 +91521,8 @@ static void uic_mqtt_dotdot_on_generated_configuration_parameters_discover_param + return; + } + +- int16_t first_parameter_id = {}; +- int16_t last_parameter_id = {}; ++ uint16_t first_parameter_id = {}; ++ uint16_t last_parameter_id = {}; + + + nlohmann::json jsn; +@@ -92593,12 +92593,12 @@ void uic_mqtt_dotdot_on_user_credential_add_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + UserTypeEnum user_type = {}; + bool user_active_state = {}; + CredRule credential_rule = {}; + std::string user_name; +- int16_t expiring_timeout_minutes = {}; ++ uint16_t expiring_timeout_minutes = {}; + UserNameEncodingType user_name_encoding = {}; + + +@@ -92682,12 +92682,12 @@ static void uic_mqtt_dotdot_on_generated_user_credential_add_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + UserTypeEnum user_type = {}; + bool user_active_state = {}; + CredRule credential_rule = {}; + std::string user_name; +- int16_t expiring_timeout_minutes = {}; ++ uint16_t expiring_timeout_minutes = {}; + UserNameEncodingType user_name_encoding = {}; + + +@@ -92772,12 +92772,12 @@ void uic_mqtt_dotdot_on_user_credential_modify_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + UserTypeEnum user_type = {}; + bool user_active_state = {}; + CredRule credential_rule = {}; + std::string user_name; +- int16_t expiring_timeout_minutes = {}; ++ uint16_t expiring_timeout_minutes = {}; + UserNameEncodingType user_name_encoding = {}; + + +@@ -92861,12 +92861,12 @@ static void uic_mqtt_dotdot_on_generated_user_credential_modify_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + UserTypeEnum user_type = {}; + bool user_active_state = {}; + CredRule credential_rule = {}; + std::string user_name; +- int16_t expiring_timeout_minutes = {}; ++ uint16_t expiring_timeout_minutes = {}; + UserNameEncodingType user_name_encoding = {}; + + +@@ -92951,7 +92951,7 @@ void uic_mqtt_dotdot_on_user_credential_delete_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -93010,7 +93010,7 @@ static void uic_mqtt_dotdot_on_generated_user_credential_delete_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -93070,9 +93070,9 @@ void uic_mqtt_dotdot_on_user_credential_add_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + std::string credential_data; + + +@@ -93144,9 +93144,9 @@ static void uic_mqtt_dotdot_on_generated_user_credential_add_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + std::string credential_data; + + +@@ -93219,9 +93219,9 @@ void uic_mqtt_dotdot_on_user_credential_modify_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + std::string credential_data; + + +@@ -93293,9 +93293,9 @@ static void uic_mqtt_dotdot_on_generated_user_credential_modify_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + std::string credential_data; + + +@@ -93368,9 +93368,9 @@ void uic_mqtt_dotdot_on_user_credential_delete_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + + + nlohmann::json jsn; +@@ -93437,9 +93437,9 @@ static void uic_mqtt_dotdot_on_generated_user_credential_delete_credential( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; ++ uint16_t credential_slot = {}; + + + nlohmann::json jsn; +@@ -93832,7 +93832,7 @@ void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -93891,7 +93891,7 @@ static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_ + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -93951,7 +93951,7 @@ void uic_mqtt_dotdot_on_user_credential_delete_all_credentials_for_user_by_type( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; + + +@@ -94015,7 +94015,7 @@ static void uic_mqtt_dotdot_on_generated_user_credential_delete_all_credentials_ + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; + + +@@ -94080,10 +94080,10 @@ void uic_mqtt_dotdot_on_user_credential_credential_learn_start_add( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; +- int8_t credential_learn_timeout = {}; ++ uint16_t credential_slot = {}; ++ uint8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -94154,10 +94154,10 @@ static void uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_ + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; +- int8_t credential_learn_timeout = {}; ++ uint16_t credential_slot = {}; ++ uint8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -94229,10 +94229,10 @@ void uic_mqtt_dotdot_on_user_credential_credential_learn_start_modify( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; +- int8_t credential_learn_timeout = {}; ++ uint16_t credential_slot = {}; ++ uint8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -94303,10 +94303,10 @@ static void uic_mqtt_dotdot_on_generated_user_credential_credential_learn_start_ + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + CredType credential_type = {}; +- int16_t credential_slot = {}; +- int8_t credential_learn_timeout = {}; ++ uint16_t credential_slot = {}; ++ uint8_t credential_learn_timeout = {}; + + + nlohmann::json jsn; +@@ -94482,10 +94482,10 @@ void uic_mqtt_dotdot_on_user_credential_credential_association( + } + + CredType credential_type = {}; +- int16_t source_user_uniqueid = {}; +- int16_t source_credential_slot = {}; +- int16_t destination_user_uniqueid = {}; +- int16_t destination_credential_slot = {}; ++ uint16_t source_user_uniqueid = {}; ++ uint16_t source_credential_slot = {}; ++ uint16_t destination_user_uniqueid = {}; ++ uint16_t destination_credential_slot = {}; + + + nlohmann::json jsn; +@@ -94561,10 +94561,10 @@ static void uic_mqtt_dotdot_on_generated_user_credential_credential_association( + } + + CredType credential_type = {}; +- int16_t source_user_uniqueid = {}; +- int16_t source_credential_slot = {}; +- int16_t destination_user_uniqueid = {}; +- int16_t destination_credential_slot = {}; ++ uint16_t source_user_uniqueid = {}; ++ uint16_t source_credential_slot = {}; ++ uint16_t destination_user_uniqueid = {}; ++ uint16_t destination_credential_slot = {}; + + + nlohmann::json jsn; +@@ -94640,7 +94640,7 @@ void uic_mqtt_dotdot_on_user_credential_get_user_checksum( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -94699,7 +94699,7 @@ static void uic_mqtt_dotdot_on_generated_user_credential_get_user_checksum( + return; + } + +- int16_t user_uniqueid = {}; ++ uint16_t user_uniqueid = {}; + + + nlohmann::json jsn; +@@ -95321,7 +95321,7 @@ static void uic_mqtt_dotdot_on_user_credential_force_read_attributes( + + sl_status_t uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( + const char *base_topic, +- int16_t value, ++ uint16_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -98108,8 +98108,8 @@ void uic_mqtt_dotdot_on_unify_humidity_control_setpoint_set( + } + + SetpointType type = {}; +- int8_t precision = {}; +- int8_t scale = {}; ++ uint8_t precision = {}; ++ uint8_t scale = {}; + int32_t value = {}; + + +@@ -98182,8 +98182,8 @@ static void uic_mqtt_dotdot_on_generated_unify_humidity_control_setpoint_set( + } + + SetpointType type = {}; +- int8_t precision = {}; +- int8_t scale = {}; ++ uint8_t precision = {}; ++ uint8_t scale = {}; + int32_t value = {}; + + +@@ -98963,7 +98963,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_scale_unr + + sl_status_t uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -99316,7 +99316,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_scale_u + + sl_status_t uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -99669,7 +99669,7 @@ sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_scale_unretain( + + sl_status_t uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + const char *base_topic, +- int8_t value, ++ uint8_t value, + uic_mqtt_dotdot_attribute_publish_type_t publish_type + ) + { +@@ -100628,7 +100628,7 @@ static inline bool uic_mqtt_dotdot_identify_identify_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t identify_time_value; ++ uint16_t identify_time_value; + memset(&identify_time_value, 0x00, sizeof(identify_time_value)); + for (const auto& callback: uic_mqtt_dotdot_identify_identify_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -100646,7 +100646,7 @@ static inline bool uic_mqtt_dotdot_identify_identify_query_response_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t timeout_value; ++ uint16_t timeout_value; + memset(&timeout_value, 0x00, sizeof(timeout_value)); + for (const auto& callback: uic_mqtt_dotdot_identify_identify_query_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -100876,7 +100876,7 @@ static inline bool uic_mqtt_dotdot_groups_add_group_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -100900,7 +100900,7 @@ static inline bool uic_mqtt_dotdot_groups_add_group_response_is_supported( + { + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + for (const auto& callback: uic_mqtt_dotdot_groups_add_group_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -100920,7 +100920,7 @@ static inline bool uic_mqtt_dotdot_groups_view_group_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + for (const auto& callback: uic_mqtt_dotdot_groups_view_group_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -100940,7 +100940,7 @@ static inline bool uic_mqtt_dotdot_groups_view_group_response_is_supported( + { + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -100980,7 +100980,7 @@ static inline bool uic_mqtt_dotdot_groups_get_group_membership_response_is_suppo + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); + for (const auto& callback: uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101000,7 +101000,7 @@ static inline bool uic_mqtt_dotdot_groups_remove_group_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101020,7 +101020,7 @@ static inline bool uic_mqtt_dotdot_groups_remove_group_response_is_supported( + { + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + for (const auto& callback: uic_mqtt_dotdot_groups_remove_group_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101054,7 +101054,7 @@ static inline bool uic_mqtt_dotdot_groups_add_group_if_identifying_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -101294,15 +101294,15 @@ static inline bool uic_mqtt_dotdot_scenes_add_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- int8_t transition_time100ms_value; ++ uint8_t transition_time100ms_value; + memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101332,9 +101332,9 @@ static inline bool uic_mqtt_dotdot_scenes_add_scene_response_is_supported( + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_add_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101356,9 +101356,9 @@ static inline bool uic_mqtt_dotdot_scenes_view_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101380,13 +101380,13 @@ static inline bool uic_mqtt_dotdot_scenes_view_scene_response_is_supported( + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_view_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101414,9 +101414,9 @@ static inline bool uic_mqtt_dotdot_scenes_remove_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101438,9 +101438,9 @@ static inline bool uic_mqtt_dotdot_scenes_remove_scene_response_is_supported( + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_remove_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101462,7 +101462,7 @@ static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101482,7 +101482,7 @@ static inline bool uic_mqtt_dotdot_scenes_remove_all_scenes_response_is_supporte + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101502,9 +101502,9 @@ static inline bool uic_mqtt_dotdot_scenes_store_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101526,9 +101526,9 @@ static inline bool uic_mqtt_dotdot_scenes_store_scene_response_is_supported( + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_store_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101550,11 +101550,11 @@ static inline bool uic_mqtt_dotdot_scenes_recall_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_recall_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101576,7 +101576,7 @@ static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101596,9 +101596,9 @@ static inline bool uic_mqtt_dotdot_scenes_get_scene_membership_response_is_suppo + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_get_scene_membership_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101622,13 +101622,13 @@ static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101656,9 +101656,9 @@ static inline bool uic_mqtt_dotdot_scenes_enhanced_add_scene_response_is_support + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101680,9 +101680,9 @@ static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101704,13 +101704,13 @@ static inline bool uic_mqtt_dotdot_scenes_enhanced_view_scene_response_is_suppor + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101740,13 +101740,13 @@ static inline bool uic_mqtt_dotdot_scenes_copy_scene_is_supported( + { + uint8_t mode_value; + memset(&mode_value, 0x00, sizeof(mode_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint8_t * group_identifier_to_value; ++ uint16_t group_identifier_to_value; + memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- int8_t scene_identifier_to_value; ++ uint8_t scene_identifier_to_value; + memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -101774,9 +101774,9 @@ static inline bool uic_mqtt_dotdot_scenes_copy_scene_response_is_supported( + { + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); + for (const auto& callback: uic_mqtt_dotdot_scenes_copy_scene_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102123,7 +102123,7 @@ static inline bool uic_mqtt_dotdot_on_off_off_with_effect_is_supported( + { + OffWithEffectEffectIdentifier effect_identifier_value; + memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- int8_t effect_variant_value; ++ uint8_t effect_variant_value; + memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); + for (const auto& callback: uic_mqtt_dotdot_on_off_off_with_effect_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102159,9 +102159,9 @@ static inline bool uic_mqtt_dotdot_on_off_on_with_timed_off_is_supported( + { + uint8_t on_off_control_value; + memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- int16_t on_time_value; ++ uint16_t on_time_value; + memset(&on_time_value, 0x00, sizeof(on_time_value)); +- int16_t off_wait_time_value; ++ uint16_t off_wait_time_value; + memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); + for (const auto& callback: uic_mqtt_dotdot_on_off_on_with_timed_off_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102373,9 +102373,9 @@ static inline bool uic_mqtt_dotdot_level_move_to_level_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102405,7 +102405,7 @@ static inline bool uic_mqtt_dotdot_level_move_is_supported( + { + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102435,9 +102435,9 @@ static inline bool uic_mqtt_dotdot_level_step_is_supported( + { + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102489,9 +102489,9 @@ static inline bool uic_mqtt_dotdot_level_move_to_level_with_on_off_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102521,7 +102521,7 @@ static inline bool uic_mqtt_dotdot_level_move_with_on_off_is_supported( + { + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102551,9 +102551,9 @@ static inline bool uic_mqtt_dotdot_level_step_with_on_off_is_supported( + { + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -102605,7 +102605,7 @@ static inline bool uic_mqtt_dotdot_level_move_to_closest_frequency_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t frequency_value; ++ uint16_t frequency_value; + memset(&frequency_value, 0x00, sizeof(frequency_value)); + for (const auto& callback: uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102836,7 +102836,7 @@ static inline bool uic_mqtt_dotdot_alarms_reset_alarm_is_supported( + { + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + for (const auto& callback: uic_mqtt_dotdot_alarms_reset_alarm_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102858,7 +102858,7 @@ static inline bool uic_mqtt_dotdot_alarms_alarm_is_supported( + { + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + for (const auto& callback: uic_mqtt_dotdot_alarms_alarm_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -102896,9 +102896,9 @@ static inline bool uic_mqtt_dotdot_alarms_get_alarm_response_is_supported( + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- int32_t time_stamp_value; ++ uint32_t time_stamp_value; + memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); + for (const auto& callback: uic_mqtt_dotdot_alarms_get_alarm_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103304,7 +103304,7 @@ static inline bool uic_mqtt_dotdot_poll_control_check_in_response_is_supported( + { + bool start_fast_polling_value; + memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- int16_t fast_poll_timeout_value; ++ uint16_t fast_poll_timeout_value; + memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); + for (const auto& callback: uic_mqtt_dotdot_poll_control_check_in_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103338,7 +103338,7 @@ static inline bool uic_mqtt_dotdot_poll_control_set_long_poll_interval_is_suppor + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int32_t new_long_poll_interval_value; ++ uint32_t new_long_poll_interval_value; + memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); + for (const auto& callback: uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103356,7 +103356,7 @@ static inline bool uic_mqtt_dotdot_poll_control_set_short_poll_interval_is_suppo + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t new_short_poll_interval_value; ++ uint16_t new_short_poll_interval_value; + memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); + for (const auto& callback: uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103705,7 +103705,7 @@ static inline bool uic_mqtt_dotdot_door_lock_lock_door_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_lock_door_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103741,7 +103741,7 @@ static inline bool uic_mqtt_dotdot_door_lock_unlock_door_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_door_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103777,7 +103777,7 @@ static inline bool uic_mqtt_dotdot_door_lock_toggle_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_toggle_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103813,9 +103813,9 @@ static inline bool uic_mqtt_dotdot_door_lock_unlock_with_timeout_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t timeout_in_seconds_value; ++ uint16_t timeout_in_seconds_value; + memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103853,7 +103853,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_log_record_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t log_index_value; ++ uint16_t log_index_value; + memset(&log_index_value, 0x00, sizeof(log_index_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103871,19 +103871,19 @@ static inline bool uic_mqtt_dotdot_door_lock_get_log_record_response_is_supporte + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t log_entryid_value; ++ uint16_t log_entryid_value; + memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- int32_t timestamp_value; ++ uint32_t timestamp_value; + memset(×tamp_value, 0x00, sizeof(timestamp_value)); + GetLogRecordResponseEventType event_type_value; + memset(&event_type_value, 0x00, sizeof(event_type_value)); + DrlkOperEventSource source_operation_event_value; + memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- int8_t event_id_or_alarm_code_value; ++ uint8_t event_id_or_alarm_code_value; + memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103913,13 +103913,13 @@ static inline bool uic_mqtt_dotdot_door_lock_set_pin_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_set_pin_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103961,7 +103961,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -103979,13 +103979,13 @@ static inline bool uic_mqtt_dotdot_door_lock_get_pin_code_response_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t code_value; ++ const char* code_value; + memset(&code_value, 0x00, sizeof(code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104009,7 +104009,7 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_pin_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104077,7 +104077,7 @@ static inline bool uic_mqtt_dotdot_door_lock_set_user_status_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -104117,7 +104117,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_user_status_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_status_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104135,7 +104135,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_user_status_response_is_support + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -104157,19 +104157,19 @@ static inline bool uic_mqtt_dotdot_door_lock_set_weekday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104217,9 +104217,9 @@ static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104239,21 +104239,21 @@ static inline bool uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_is_su + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104285,9 +104285,9 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_weekday_schedule_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104325,13 +104325,13 @@ static inline bool uic_mqtt_dotdot_door_lock_set_year_day_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104373,9 +104373,9 @@ static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104395,15 +104395,15 @@ static inline bool uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_is_s + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104429,9 +104429,9 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_year_day_schedule_is_supporte + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104469,11 +104469,11 @@ static inline bool uic_mqtt_dotdot_door_lock_set_holiday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -104517,7 +104517,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104535,13 +104535,13 @@ static inline bool uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_is_su + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -104569,7 +104569,7 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_holiday_schedule_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104605,7 +104605,7 @@ static inline bool uic_mqtt_dotdot_door_lock_set_user_type_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -104645,7 +104645,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_user_type_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_type_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104663,7 +104663,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_user_type_response_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -104685,13 +104685,13 @@ static inline bool uic_mqtt_dotdot_door_lock_set_rfid_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104733,7 +104733,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104751,13 +104751,13 @@ static inline bool uic_mqtt_dotdot_door_lock_get_rfid_code_response_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104781,7 +104781,7 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_rfid_code_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104851,11 +104851,11 @@ static inline bool uic_mqtt_dotdot_door_lock_set_user_is_supported( + { + DataOperationTypeEnum operation_type_value; + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int32_t user_uniqueid_value; ++ uint32_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -104891,7 +104891,7 @@ static inline bool uic_mqtt_dotdot_door_lock_get_user_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_get_user_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104923,7 +104923,7 @@ static inline bool uic_mqtt_dotdot_door_lock_clear_user_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_clear_user_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -104945,11 +104945,11 @@ static inline bool uic_mqtt_dotdot_door_lock_operating_event_notification_is_sup + memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); + OperatingEventNotificationOperationEventCode operation_event_code_value; + memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -104983,15 +104983,15 @@ static inline bool uic_mqtt_dotdot_door_lock_programming_event_notification_is_s + memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); + ProgrammingEventNotificationProgramEventCode program_event_code_value; + memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -105029,9 +105029,9 @@ static inline bool uic_mqtt_dotdot_door_lock_set_credential_is_supported( + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); + CredentialStruct credential_value; + memset(&credential_value, 0x00, sizeof(credential_value)); +- uint8_t credential_data_value; ++ const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -105127,7 +105127,7 @@ static inline bool uic_mqtt_dotdot_door_lock_unbolt_door_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t pin_code_value; ++ const char* pin_code_value; + memset(&pin_code_value, 0x00, sizeof(pin_code_value)); + for (const auto& callback: uic_mqtt_dotdot_door_lock_unbolt_door_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -105783,7 +105783,7 @@ static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_value_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t lift_value_value; ++ uint16_t lift_value_value; + memset(&lift_value_value, 0x00, sizeof(lift_value_value)); + for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -105801,7 +105801,7 @@ static inline bool uic_mqtt_dotdot_window_covering_go_to_lift_percentage_is_supp + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t percentage_lift_value_value; ++ uint8_t percentage_lift_value_value; + memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); + for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -105819,7 +105819,7 @@ static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_value_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t tilt_value_value; ++ uint16_t tilt_value_value; + memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); + for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -105837,7 +105837,7 @@ static inline bool uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_is_supp + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t percentage_tilt_value_value; ++ uint8_t percentage_tilt_value_value; + memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); + for (const auto& callback: uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -106052,7 +106052,7 @@ static inline bool uic_mqtt_dotdot_barrier_control_go_to_percent_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t percent_open_value; ++ uint8_t percent_open_value; + memset(&percent_open_value, 0x00, sizeof(percent_open_value)); + for (const auto& callback: uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -106472,17 +106472,17 @@ static inline bool uic_mqtt_dotdot_thermostat_get_relay_status_log_response_is_s + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t time_of_day_value; ++ uint16_t time_of_day_value; + memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); + uint8_t relay_status_value; + memset(&relay_status_value, 0x00, sizeof(relay_status_value)); + int16_t local_temperature_value; + memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- int8_t humidity_percentage_value; ++ uint8_t humidity_percentage_value; + memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); + int16_t set_point_value; + memset(&set_point_value, 0x00, sizeof(set_point_value)); +- int16_t unread_entries_value; ++ uint16_t unread_entries_value; + memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); + for (const auto& callback: uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -107201,11 +107201,11 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_hue_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107237,7 +107237,7 @@ static inline bool uic_mqtt_dotdot_color_control_move_hue_is_supported( + { + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107267,9 +107267,9 @@ static inline bool uic_mqtt_dotdot_color_control_step_hue_is_supported( + { + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107299,9 +107299,9 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_saturation_is_supported + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107331,7 +107331,7 @@ static inline bool uic_mqtt_dotdot_color_control_move_saturation_is_supported( + { + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107361,9 +107361,9 @@ static inline bool uic_mqtt_dotdot_color_control_step_saturation_is_supported( + { + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107393,11 +107393,11 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_is_s + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107427,11 +107427,11 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_color_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t colorx_value; ++ uint16_t colorx_value; + memset(&colorx_value, 0x00, sizeof(colorx_value)); +- int16_t colory_value; ++ uint16_t colory_value; + memset(&colory_value, 0x00, sizeof(colory_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107495,7 +107495,7 @@ static inline bool uic_mqtt_dotdot_color_control_step_color_is_supported( + memset(&stepx_value, 0x00, sizeof(stepx_value)); + int16_t stepy_value; + memset(&stepy_value, 0x00, sizeof(stepy_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107525,9 +107525,9 @@ static inline bool uic_mqtt_dotdot_color_control_move_to_color_temperature_is_su + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t color_temperature_mireds_value; ++ uint16_t color_temperature_mireds_value; + memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107555,11 +107555,11 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_is_support + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107591,7 +107591,7 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_move_hue_is_supported( + { + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107621,9 +107621,9 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_step_hue_is_supported( + { + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107653,11 +107653,11 @@ static inline bool uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_satura + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107693,9 +107693,9 @@ static inline bool uic_mqtt_dotdot_color_control_color_loop_set_is_supported( + memset(&action_value, 0x00, sizeof(action_value)); + CCColorLoopDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t time_value; ++ uint16_t time_value; + memset(&time_value, 0x00, sizeof(time_value)); +- int16_t start_hue_value; ++ uint16_t start_hue_value; + memset(&start_hue_value, 0x00, sizeof(start_hue_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107753,11 +107753,11 @@ static inline bool uic_mqtt_dotdot_color_control_move_color_temperature_is_suppo + { + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -107791,13 +107791,13 @@ static inline bool uic_mqtt_dotdot_color_control_step_color_temperature_is_suppo + { + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -110334,7 +110334,7 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_response_is_supported( + { + ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; + memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); + for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -110358,9 +110358,9 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_status_change_notification_is_s + memset(&zone_status_value, 0x00, sizeof(zone_status_value)); + uint8_t extended_status_value; + memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- int16_t delay_value; ++ uint16_t delay_value; + memset(&delay_value, 0x00, sizeof(delay_value)); + for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -110400,7 +110400,7 @@ static inline bool uic_mqtt_dotdot_ias_zone_zone_enroll_request_is_supported( + { + IasZoneType zone_type_value; + memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- int16_t manufacturer_code_value; ++ uint16_t manufacturer_code_value; + memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); + for (const auto& callback: uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -110420,9 +110420,9 @@ static inline bool uic_mqtt_dotdot_ias_zone_initiate_test_mode_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t test_mode_duration_value; ++ uint8_t test_mode_duration_value; + memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- int8_t current_zone_sensitivity_level_value; ++ uint8_t current_zone_sensitivity_level_value; + memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); + for (const auto& callback: uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -110627,9 +110627,9 @@ static inline bool uic_mqtt_dotdot_iaswd_start_warning_is_supported( + { + uint8_t siren_configuration_value; + memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- int16_t warning_duration_value; ++ uint16_t warning_duration_value; + memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- int8_t strobe_duty_cycle_value; ++ uint8_t strobe_duty_cycle_value; + memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); + IaswdLevel strobe_level_value; + memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +@@ -110983,11 +110983,11 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_profile_info_respo + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int8_t profile_count_value; ++ uint8_t profile_count_value; + memset(&profile_count_value, 0x00, sizeof(profile_count_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t max_number_of_intervals_value; ++ uint8_t max_number_of_intervals_value; + memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); + for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -111025,15 +111025,15 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); + GetMeasurementProfileResponseStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t number_of_intervals_delivered_value; ++ uint8_t number_of_intervals_delivered_value; + memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint8_t attribute_id_value; ++ uint16_t attribute_id_value; + memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); + for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -111061,11 +111061,11 @@ static inline bool uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- uint8_t attributeid_value; ++ uint16_t attributeid_value; + memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); +- int8_t number_of_intervals_value; ++ uint8_t number_of_intervals_value; + memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); + for (const auto& callback: uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -111417,13 +111417,13 @@ static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is + memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); + bool transmission_successful_value; + memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- int16_t transmission_time_ms_value; ++ uint16_t transmission_time_ms_value; + memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); + int8_t tx_powerd_bm_value; + memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- int8_t tx_channel_value; ++ uint8_t tx_channel_value; + memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- int8_t routing_attempts_value; ++ uint8_t routing_attempts_value; + memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); + bool route_changed_value; + memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +@@ -111433,7 +111433,7 @@ static inline bool uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_is + memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); + int8_t ackrssi_value; + memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- int8_t ack_channel_value; ++ uint8_t ack_channel_value; + memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); + const char* last_route_failed_link_functionalunid_value; + memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +@@ -111928,7 +111928,7 @@ static inline bool uic_mqtt_dotdot_binding_bind_is_supported( + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + for (const auto& callback: uic_mqtt_dotdot_binding_bind_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -111954,7 +111954,7 @@ static inline bool uic_mqtt_dotdot_binding_unbind_is_supported( + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + for (const auto& callback: uic_mqtt_dotdot_binding_unbind_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -112667,7 +112667,7 @@ static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_i + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -112699,7 +112699,7 @@ static inline bool uic_mqtt_dotdot_configuration_parameters_set_parameter_is_sup + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + int64_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -112721,9 +112721,9 @@ static inline bool uic_mqtt_dotdot_configuration_parameters_discover_parameter_r + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t first_parameter_id_value; ++ uint16_t first_parameter_id_value; + memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- int16_t last_parameter_id_value; ++ uint16_t last_parameter_id_value; + memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); + for (const auto& callback: uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -112919,7 +112919,7 @@ static inline bool uic_mqtt_dotdot_user_credential_add_user_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -112929,7 +112929,7 @@ static inline bool uic_mqtt_dotdot_user_credential_add_user_is_supported( + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -112961,7 +112961,7 @@ static inline bool uic_mqtt_dotdot_user_credential_modify_user_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -112971,7 +112971,7 @@ static inline bool uic_mqtt_dotdot_user_credential_modify_user_is_supported( + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -113003,7 +113003,7 @@ static inline bool uic_mqtt_dotdot_user_credential_delete_user_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_user_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113021,11 +113021,11 @@ static inline bool uic_mqtt_dotdot_user_credential_add_credential_is_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -113051,11 +113051,11 @@ static inline bool uic_mqtt_dotdot_user_credential_modify_credential_is_supporte + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -113081,11 +113081,11 @@ static inline bool uic_mqtt_dotdot_user_credential_delete_credential_is_supporte + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_credential_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113153,7 +113153,7 @@ static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_for_us + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113171,7 +113171,7 @@ static inline bool uic_mqtt_dotdot_user_credential_delete_all_credentials_for_us + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +@@ -113193,13 +113193,13 @@ static inline bool uic_mqtt_dotdot_user_credential_credential_learn_start_add_is + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113223,13 +113223,13 @@ static inline bool uic_mqtt_dotdot_user_credential_credential_learn_start_modify + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113269,13 +113269,13 @@ static inline bool uic_mqtt_dotdot_user_credential_credential_association_is_sup + { + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t source_user_uniqueid_value; ++ uint16_t source_user_uniqueid_value; + memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); +- int16_t source_credential_slot_value; ++ uint16_t source_credential_slot_value; + memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); +- int16_t destination_user_uniqueid_value; ++ uint16_t destination_user_uniqueid_value; + memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); +- int16_t destination_credential_slot_value; ++ uint16_t destination_credential_slot_value; + memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_credential_association_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -113301,7 +113301,7 @@ static inline bool uic_mqtt_dotdot_user_credential_get_user_checksum_is_supporte + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id) + { +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + for (const auto& callback: uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { + if (callback( unid, endpoint_id, UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -114349,9 +114349,9 @@ static inline bool uic_mqtt_dotdot_unify_humidity_control_setpoint_set_is_suppor + { + SetpointType type_value; + memset(&type_value, 0x00, sizeof(type_value)); +- int8_t precision_value; ++ uint8_t precision_value; + memset(&precision_value, 0x00, sizeof(precision_value)); +- int8_t scale_value; ++ uint8_t scale_value; + memset(&scale_value, 0x00, sizeof(scale_value)); + int32_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp +index a954bd2658..cef2277e5a 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt.hpp +@@ -5653,7 +5653,7 @@ const std::vector, std::vector, std::vector>>> DeviceTemperatureConfigurationDeviceTempAlarmMask_bitmap_data { + { {"DeviceTemperatureTooLow", "bool", "0x1", "0"}, { +@@ -6089,7 +6089,7 @@ const std::vector, std::vector, std::vector>>> PowerConfigurationMainsAlarmMask_bitmap_data { + { {"MainsVoltageTooLow", "bool", "0x1", "0"}, { +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp +index 200e293797..87fddb1ebf 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_attributes.cpp +@@ -135,7 +135,7 @@ static void uic_mqtt_dotdot_on_basic_zcl_version_attribute_update( + } + + +- int8_t zcl_version = {}; ++ uint8_t zcl_version = {}; + + nlohmann::json json_payload; + try { +@@ -148,7 +148,7 @@ static void uic_mqtt_dotdot_on_basic_zcl_version_attribute_update( + return; + } + // Start parsing value +- zcl_version = json_payload.at("value").get(); ++ zcl_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -211,7 +211,7 @@ static void uic_mqtt_dotdot_on_basic_application_version_attribute_update( + } + + +- int8_t application_version = {}; ++ uint8_t application_version = {}; + + nlohmann::json json_payload; + try { +@@ -224,7 +224,7 @@ static void uic_mqtt_dotdot_on_basic_application_version_attribute_update( + return; + } + // Start parsing value +- application_version = json_payload.at("value").get(); ++ application_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -287,7 +287,7 @@ static void uic_mqtt_dotdot_on_basic_stack_version_attribute_update( + } + + +- int8_t stack_version = {}; ++ uint8_t stack_version = {}; + + nlohmann::json json_payload; + try { +@@ -300,7 +300,7 @@ static void uic_mqtt_dotdot_on_basic_stack_version_attribute_update( + return; + } + // Start parsing value +- stack_version = json_payload.at("value").get(); ++ stack_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -363,7 +363,7 @@ static void uic_mqtt_dotdot_on_basic_hw_version_attribute_update( + } + + +- int8_t hw_version = {}; ++ uint8_t hw_version = {}; + + nlohmann::json json_payload; + try { +@@ -376,7 +376,7 @@ static void uic_mqtt_dotdot_on_basic_hw_version_attribute_update( + return; + } + // Start parsing value +- hw_version = json_payload.at("value").get(); ++ hw_version = json_payload.at("value").get(); + + // End parsing value + } +@@ -919,7 +919,7 @@ static void uic_mqtt_dotdot_on_basic_product_code_attribute_update( + } + + +- uint8_t product_code = {}; ++ const char* product_code = {}; + + nlohmann::json json_payload; + try { +@@ -2015,7 +2015,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_attribute_updat + } + + +- int16_t mains_voltage = {}; ++ uint16_t mains_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2028,7 +2028,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_attribute_updat + return; + } + // Start parsing value +- mains_voltage = json_payload.at("value").get(); ++ mains_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -2091,7 +2091,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_frequency_attribute_upd + } + + +- int8_t mains_frequency = {}; ++ uint8_t mains_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -2104,7 +2104,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_frequency_attribute_upd + return; + } + // Start parsing value +- mains_frequency = json_payload.at("value").get(); ++ mains_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -2243,7 +2243,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_min_threshold_a + } + + +- int16_t mains_voltage_min_threshold = {}; ++ uint16_t mains_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -2256,7 +2256,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_min_threshold_a + return; + } + // Start parsing value +- mains_voltage_min_threshold = json_payload.at("value").get(); ++ mains_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -2319,7 +2319,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_max_threshold_a + } + + +- int16_t mains_voltage_max_threshold = {}; ++ uint16_t mains_voltage_max_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -2332,7 +2332,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_max_threshold_a + return; + } + // Start parsing value +- mains_voltage_max_threshold = json_payload.at("value").get(); ++ mains_voltage_max_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -2395,7 +2395,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_dwell_trip_poin + } + + +- int16_t mains_voltage_dwell_trip_point = {}; ++ uint16_t mains_voltage_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -2408,7 +2408,7 @@ static void uic_mqtt_dotdot_on_power_configuration_mains_voltage_dwell_trip_poin + return; + } + // Start parsing value +- mains_voltage_dwell_trip_point = json_payload.at("value").get(); ++ mains_voltage_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -2471,7 +2471,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_attribute_upd + } + + +- int8_t battery_voltage = {}; ++ uint8_t battery_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2484,7 +2484,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_attribute_upd + return; + } + // Start parsing value +- battery_voltage = json_payload.at("value").get(); ++ battery_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -2547,7 +2547,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_remaining_ + } + + +- int8_t battery_percentage_remaining = {}; ++ uint8_t battery_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -2560,7 +2560,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_remaining_ + return; + } + // Start parsing value +- battery_percentage_remaining = json_payload.at("value").get(); ++ battery_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -2783,7 +2783,7 @@ static void uic_mqtt_dotdot_on_power_configuration_batterya_hr_rating_attribute_ + } + + +- int16_t batterya_hr_rating = {}; ++ uint16_t batterya_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -2796,7 +2796,7 @@ static void uic_mqtt_dotdot_on_power_configuration_batterya_hr_rating_attribute_ + return; + } + // Start parsing value +- batterya_hr_rating = json_payload.at("value").get(); ++ batterya_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -2859,7 +2859,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_quantity_attribute_up + } + + +- int8_t battery_quantity = {}; ++ uint8_t battery_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -2872,7 +2872,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_quantity_attribute_up + return; + } + // Start parsing value +- battery_quantity = json_payload.at("value").get(); ++ battery_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -2935,7 +2935,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_rated_voltage_attribu + } + + +- int8_t battery_rated_voltage = {}; ++ uint8_t battery_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -2948,7 +2948,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_rated_voltage_attribu + return; + } + // Start parsing value +- battery_rated_voltage = json_payload.at("value").get(); ++ battery_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -3087,7 +3087,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_min_threshold + } + + +- int8_t battery_voltage_min_threshold = {}; ++ uint8_t battery_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -3100,7 +3100,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_min_threshold + return; + } + // Start parsing value +- battery_voltage_min_threshold = json_payload.at("value").get(); ++ battery_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -3163,7 +3163,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold1_at + } + + +- int8_t battery_voltage_threshold1 = {}; ++ uint8_t battery_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -3176,7 +3176,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold1_at + return; + } + // Start parsing value +- battery_voltage_threshold1 = json_payload.at("value").get(); ++ battery_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3239,7 +3239,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold2_at + } + + +- int8_t battery_voltage_threshold2 = {}; ++ uint8_t battery_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -3252,7 +3252,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold2_at + return; + } + // Start parsing value +- battery_voltage_threshold2 = json_payload.at("value").get(); ++ battery_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3315,7 +3315,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold3_at + } + + +- int8_t battery_voltage_threshold3 = {}; ++ uint8_t battery_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -3328,7 +3328,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_voltage_threshold3_at + return; + } + // Start parsing value +- battery_voltage_threshold3 = json_payload.at("value").get(); ++ battery_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3391,7 +3391,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_min_thresh + } + + +- int8_t battery_percentage_min_threshold = {}; ++ uint8_t battery_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -3404,7 +3404,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_min_thresh + return; + } + // Start parsing value +- battery_percentage_min_threshold = json_payload.at("value").get(); ++ battery_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -3467,7 +3467,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold1 + } + + +- int8_t battery_percentage_threshold1 = {}; ++ uint8_t battery_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -3480,7 +3480,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold1 + return; + } + // Start parsing value +- battery_percentage_threshold1 = json_payload.at("value").get(); ++ battery_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3543,7 +3543,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold2 + } + + +- int8_t battery_percentage_threshold2 = {}; ++ uint8_t battery_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -3556,7 +3556,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold2 + return; + } + // Start parsing value +- battery_percentage_threshold2 = json_payload.at("value").get(); ++ battery_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3619,7 +3619,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold3 + } + + +- int8_t battery_percentage_threshold3 = {}; ++ uint8_t battery_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -3632,7 +3632,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery_percentage_threshold3 + return; + } + // Start parsing value +- battery_percentage_threshold3 = json_payload.at("value").get(); ++ battery_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -3771,7 +3771,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_attribute_up + } + + +- int8_t battery2_voltage = {}; ++ uint8_t battery2_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -3784,7 +3784,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_attribute_up + return; + } + // Start parsing value +- battery2_voltage = json_payload.at("value").get(); ++ battery2_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -3847,7 +3847,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_remaining + } + + +- int8_t battery2_percentage_remaining = {}; ++ uint8_t battery2_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -3860,7 +3860,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_remaining + return; + } + // Start parsing value +- battery2_percentage_remaining = json_payload.at("value").get(); ++ battery2_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -4083,7 +4083,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2a_hr_rating_attribute + } + + +- int16_t battery2a_hr_rating = {}; ++ uint16_t battery2a_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -4096,7 +4096,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2a_hr_rating_attribute + return; + } + // Start parsing value +- battery2a_hr_rating = json_payload.at("value").get(); ++ battery2a_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -4159,7 +4159,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_quantity_attribute_u + } + + +- int8_t battery2_quantity = {}; ++ uint8_t battery2_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -4172,7 +4172,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_quantity_attribute_u + return; + } + // Start parsing value +- battery2_quantity = json_payload.at("value").get(); ++ battery2_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -4235,7 +4235,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_rated_voltage_attrib + } + + +- int8_t battery2_rated_voltage = {}; ++ uint8_t battery2_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -4248,7 +4248,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_rated_voltage_attrib + return; + } + // Start parsing value +- battery2_rated_voltage = json_payload.at("value").get(); ++ battery2_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -4387,7 +4387,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_min_threshol + } + + +- int8_t battery2_voltage_min_threshold = {}; ++ uint8_t battery2_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -4400,7 +4400,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_min_threshol + return; + } + // Start parsing value +- battery2_voltage_min_threshold = json_payload.at("value").get(); ++ battery2_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -4463,7 +4463,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold1_a + } + + +- int8_t battery2_voltage_threshold1 = {}; ++ uint8_t battery2_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -4476,7 +4476,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold1_a + return; + } + // Start parsing value +- battery2_voltage_threshold1 = json_payload.at("value").get(); ++ battery2_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4539,7 +4539,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold2_a + } + + +- int8_t battery2_voltage_threshold2 = {}; ++ uint8_t battery2_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -4552,7 +4552,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold2_a + return; + } + // Start parsing value +- battery2_voltage_threshold2 = json_payload.at("value").get(); ++ battery2_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4615,7 +4615,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold3_a + } + + +- int8_t battery2_voltage_threshold3 = {}; ++ uint8_t battery2_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -4628,7 +4628,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_voltage_threshold3_a + return; + } + // Start parsing value +- battery2_voltage_threshold3 = json_payload.at("value").get(); ++ battery2_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4691,7 +4691,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_min_thres + } + + +- int8_t battery2_percentage_min_threshold = {}; ++ uint8_t battery2_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -4704,7 +4704,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_min_thres + return; + } + // Start parsing value +- battery2_percentage_min_threshold = json_payload.at("value").get(); ++ battery2_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -4767,7 +4767,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- int8_t battery2_percentage_threshold1 = {}; ++ uint8_t battery2_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -4780,7 +4780,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold1 = json_payload.at("value").get(); ++ battery2_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4843,7 +4843,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- int8_t battery2_percentage_threshold2 = {}; ++ uint8_t battery2_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -4856,7 +4856,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold2 = json_payload.at("value").get(); ++ battery2_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -4919,7 +4919,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + } + + +- int8_t battery2_percentage_threshold3 = {}; ++ uint8_t battery2_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -4932,7 +4932,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery2_percentage_threshold + return; + } + // Start parsing value +- battery2_percentage_threshold3 = json_payload.at("value").get(); ++ battery2_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5071,7 +5071,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_attribute_up + } + + +- int8_t battery3_voltage = {}; ++ uint8_t battery3_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -5084,7 +5084,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_attribute_up + return; + } + // Start parsing value +- battery3_voltage = json_payload.at("value").get(); ++ battery3_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -5147,7 +5147,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_remaining + } + + +- int8_t battery3_percentage_remaining = {}; ++ uint8_t battery3_percentage_remaining = {}; + + nlohmann::json json_payload; + try { +@@ -5160,7 +5160,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_remaining + return; + } + // Start parsing value +- battery3_percentage_remaining = json_payload.at("value").get(); ++ battery3_percentage_remaining = json_payload.at("value").get(); + + // End parsing value + } +@@ -5383,7 +5383,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3a_hr_rating_attribute + } + + +- int16_t battery3a_hr_rating = {}; ++ uint16_t battery3a_hr_rating = {}; + + nlohmann::json json_payload; + try { +@@ -5396,7 +5396,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3a_hr_rating_attribute + return; + } + // Start parsing value +- battery3a_hr_rating = json_payload.at("value").get(); ++ battery3a_hr_rating = json_payload.at("value").get(); + + // End parsing value + } +@@ -5459,7 +5459,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_quantity_attribute_u + } + + +- int8_t battery3_quantity = {}; ++ uint8_t battery3_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -5472,7 +5472,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_quantity_attribute_u + return; + } + // Start parsing value +- battery3_quantity = json_payload.at("value").get(); ++ battery3_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -5535,7 +5535,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_rated_voltage_attrib + } + + +- int8_t battery3_rated_voltage = {}; ++ uint8_t battery3_rated_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -5548,7 +5548,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_rated_voltage_attrib + return; + } + // Start parsing value +- battery3_rated_voltage = json_payload.at("value").get(); ++ battery3_rated_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -5687,7 +5687,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_min_threshol + } + + +- int8_t battery3_voltage_min_threshold = {}; ++ uint8_t battery3_voltage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -5700,7 +5700,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_min_threshol + return; + } + // Start parsing value +- battery3_voltage_min_threshold = json_payload.at("value").get(); ++ battery3_voltage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -5763,7 +5763,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold1_a + } + + +- int8_t battery3_voltage_threshold1 = {}; ++ uint8_t battery3_voltage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -5776,7 +5776,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold1_a + return; + } + // Start parsing value +- battery3_voltage_threshold1 = json_payload.at("value").get(); ++ battery3_voltage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5839,7 +5839,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold2_a + } + + +- int8_t battery3_voltage_threshold2 = {}; ++ uint8_t battery3_voltage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -5852,7 +5852,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold2_a + return; + } + // Start parsing value +- battery3_voltage_threshold2 = json_payload.at("value").get(); ++ battery3_voltage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5915,7 +5915,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold3_a + } + + +- int8_t battery3_voltage_threshold3 = {}; ++ uint8_t battery3_voltage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -5928,7 +5928,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_voltage_threshold3_a + return; + } + // Start parsing value +- battery3_voltage_threshold3 = json_payload.at("value").get(); ++ battery3_voltage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -5991,7 +5991,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_min_thres + } + + +- int8_t battery3_percentage_min_threshold = {}; ++ uint8_t battery3_percentage_min_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -6004,7 +6004,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_min_thres + return; + } + // Start parsing value +- battery3_percentage_min_threshold = json_payload.at("value").get(); ++ battery3_percentage_min_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -6067,7 +6067,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- int8_t battery3_percentage_threshold1 = {}; ++ uint8_t battery3_percentage_threshold1 = {}; + + nlohmann::json json_payload; + try { +@@ -6080,7 +6080,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold1 = json_payload.at("value").get(); ++ battery3_percentage_threshold1 = json_payload.at("value").get(); + + // End parsing value + } +@@ -6143,7 +6143,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- int8_t battery3_percentage_threshold2 = {}; ++ uint8_t battery3_percentage_threshold2 = {}; + + nlohmann::json json_payload; + try { +@@ -6156,7 +6156,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold2 = json_payload.at("value").get(); ++ battery3_percentage_threshold2 = json_payload.at("value").get(); + + // End parsing value + } +@@ -6219,7 +6219,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + } + + +- int8_t battery3_percentage_threshold3 = {}; ++ uint8_t battery3_percentage_threshold3 = {}; + + nlohmann::json json_payload; + try { +@@ -6232,7 +6232,7 @@ static void uic_mqtt_dotdot_on_power_configuration_battery3_percentage_threshold + return; + } + // Start parsing value +- battery3_percentage_threshold3 = json_payload.at("value").get(); ++ battery3_percentage_threshold3 = json_payload.at("value").get(); + + // End parsing value + } +@@ -7091,7 +7091,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_over_temp_total_ + } + + +- int16_t over_temp_total_dwell = {}; ++ uint16_t over_temp_total_dwell = {}; + + nlohmann::json json_payload; + try { +@@ -7104,7 +7104,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_over_temp_total_ + return; + } + // Start parsing value +- over_temp_total_dwell = json_payload.at("value").get(); ++ over_temp_total_dwell = json_payload.at("value").get(); + + // End parsing value + } +@@ -7395,7 +7395,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_low_temp_dwell_t + } + + +- int32_t low_temp_dwell_trip_point = {}; ++ uint32_t low_temp_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -7408,7 +7408,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_low_temp_dwell_t + return; + } + // Start parsing value +- low_temp_dwell_trip_point = json_payload.at("value").get(); ++ low_temp_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -7471,7 +7471,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_high_temp_dwell_ + } + + +- int32_t high_temp_dwell_trip_point = {}; ++ uint32_t high_temp_dwell_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -7484,7 +7484,7 @@ static void uic_mqtt_dotdot_on_device_temperature_configuration_high_temp_dwell_ + return; + } + // Start parsing value +- high_temp_dwell_trip_point = json_payload.at("value").get(); ++ high_temp_dwell_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -7647,7 +7647,7 @@ static void uic_mqtt_dotdot_on_identify_identify_time_attribute_update( + } + + +- int16_t identify_time = {}; ++ uint16_t identify_time = {}; + + nlohmann::json json_payload; + try { +@@ -7660,7 +7660,7 @@ static void uic_mqtt_dotdot_on_identify_identify_time_attribute_update( + return; + } + // Start parsing value +- identify_time = json_payload.at("value").get(); ++ identify_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -7877,7 +7877,7 @@ static void uic_mqtt_dotdot_on_scenes_scene_count_attribute_update( + } + + +- int8_t scene_count = {}; ++ uint8_t scene_count = {}; + + nlohmann::json json_payload; + try { +@@ -7890,7 +7890,7 @@ static void uic_mqtt_dotdot_on_scenes_scene_count_attribute_update( + return; + } + // Start parsing value +- scene_count = json_payload.at("value").get(); ++ scene_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -7953,7 +7953,7 @@ static void uic_mqtt_dotdot_on_scenes_current_scene_attribute_update( + } + + +- int8_t current_scene = {}; ++ uint8_t current_scene = {}; + + nlohmann::json json_payload; + try { +@@ -7966,7 +7966,7 @@ static void uic_mqtt_dotdot_on_scenes_current_scene_attribute_update( + return; + } + // Start parsing value +- current_scene = json_payload.at("value").get(); ++ current_scene = json_payload.at("value").get(); + + // End parsing value + } +@@ -8029,7 +8029,7 @@ static void uic_mqtt_dotdot_on_scenes_current_group_attribute_update( + } + + +- uint8_t * current_group = {}; ++ uint16_t current_group = {}; + + nlohmann::json json_payload; + try { +@@ -8042,7 +8042,7 @@ static void uic_mqtt_dotdot_on_scenes_current_group_attribute_update( + return; + } + // Start parsing value +- current_group = json_payload.at("value").get(); ++ current_group = json_payload.at("value").get(); + + // End parsing value + } +@@ -8350,11 +8350,11 @@ static void uic_mqtt_dotdot_on_scenes_scene_table_attribute_update( + auto &scene_table_json = json_payload.at("value"); + for (size_t i = 0; i < scene_table_json.size(); i++) { + SSceneTable element = {}; +- element.SceneID = scene_table_json.at(i).at("SceneID").get(); +- element.GroupID = scene_table_json.at(i).at("GroupID").get(); ++ element.SceneID = scene_table_json.at(i).at("SceneID").get(); ++ element.GroupID = scene_table_json.at(i).at("GroupID").get(); + element.SceneName = scene_table_json.at(i).at("SceneName").get_ptr()->c_str(); +- element.TransitionTime = scene_table_json.at(i).at("TransitionTime").get(); +- element.TransitionTime100ms = scene_table_json.at(i).at("TransitionTime100ms").get(); ++ element.TransitionTime = scene_table_json.at(i).at("TransitionTime").get(); ++ element.TransitionTime100ms = scene_table_json.at(i).at("TransitionTime100ms").get(); + element.SceneTableExtensions = scene_table_json.at(i).at("SceneTableExtensions").get_ptr()->c_str(); + scene_table.push_back(element); + } +@@ -8663,7 +8663,7 @@ static void uic_mqtt_dotdot_on_on_off_on_time_attribute_update( + } + + +- int16_t on_time = {}; ++ uint16_t on_time = {}; + + nlohmann::json json_payload; + try { +@@ -8676,7 +8676,7 @@ static void uic_mqtt_dotdot_on_on_off_on_time_attribute_update( + return; + } + // Start parsing value +- on_time = json_payload.at("value").get(); ++ on_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -8739,7 +8739,7 @@ static void uic_mqtt_dotdot_on_on_off_off_wait_time_attribute_update( + } + + +- int16_t off_wait_time = {}; ++ uint16_t off_wait_time = {}; + + nlohmann::json json_payload; + try { +@@ -8752,7 +8752,7 @@ static void uic_mqtt_dotdot_on_on_off_off_wait_time_attribute_update( + return; + } + // Start parsing value +- off_wait_time = json_payload.at("value").get(); ++ off_wait_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -8980,7 +8980,7 @@ static void uic_mqtt_dotdot_on_level_current_level_attribute_update( + } + + +- int8_t current_level = {}; ++ uint8_t current_level = {}; + + nlohmann::json json_payload; + try { +@@ -8993,7 +8993,7 @@ static void uic_mqtt_dotdot_on_level_current_level_attribute_update( + return; + } + // Start parsing value +- current_level = json_payload.at("value").get(); ++ current_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9056,7 +9056,7 @@ static void uic_mqtt_dotdot_on_level_remaining_time_attribute_update( + } + + +- int16_t remaining_time = {}; ++ uint16_t remaining_time = {}; + + nlohmann::json json_payload; + try { +@@ -9069,7 +9069,7 @@ static void uic_mqtt_dotdot_on_level_remaining_time_attribute_update( + return; + } + // Start parsing value +- remaining_time = json_payload.at("value").get(); ++ remaining_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9132,7 +9132,7 @@ static void uic_mqtt_dotdot_on_level_min_level_attribute_update( + } + + +- int8_t min_level = {}; ++ uint8_t min_level = {}; + + nlohmann::json json_payload; + try { +@@ -9145,7 +9145,7 @@ static void uic_mqtt_dotdot_on_level_min_level_attribute_update( + return; + } + // Start parsing value +- min_level = json_payload.at("value").get(); ++ min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9208,7 +9208,7 @@ static void uic_mqtt_dotdot_on_level_max_level_attribute_update( + } + + +- int8_t max_level = {}; ++ uint8_t max_level = {}; + + nlohmann::json json_payload; + try { +@@ -9221,7 +9221,7 @@ static void uic_mqtt_dotdot_on_level_max_level_attribute_update( + return; + } + // Start parsing value +- max_level = json_payload.at("value").get(); ++ max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9284,7 +9284,7 @@ static void uic_mqtt_dotdot_on_level_current_frequency_attribute_update( + } + + +- int16_t current_frequency = {}; ++ uint16_t current_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9297,7 +9297,7 @@ static void uic_mqtt_dotdot_on_level_current_frequency_attribute_update( + return; + } + // Start parsing value +- current_frequency = json_payload.at("value").get(); ++ current_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9360,7 +9360,7 @@ static void uic_mqtt_dotdot_on_level_min_frequency_attribute_update( + } + + +- int16_t min_frequency = {}; ++ uint16_t min_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9373,7 +9373,7 @@ static void uic_mqtt_dotdot_on_level_min_frequency_attribute_update( + return; + } + // Start parsing value +- min_frequency = json_payload.at("value").get(); ++ min_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9436,7 +9436,7 @@ static void uic_mqtt_dotdot_on_level_max_frequency_attribute_update( + } + + +- int16_t max_frequency = {}; ++ uint16_t max_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -9449,7 +9449,7 @@ static void uic_mqtt_dotdot_on_level_max_frequency_attribute_update( + return; + } + // Start parsing value +- max_frequency = json_payload.at("value").get(); ++ max_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -9588,7 +9588,7 @@ static void uic_mqtt_dotdot_on_level_on_off_transition_time_attribute_update( + } + + +- int16_t on_off_transition_time = {}; ++ uint16_t on_off_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9601,7 +9601,7 @@ static void uic_mqtt_dotdot_on_level_on_off_transition_time_attribute_update( + return; + } + // Start parsing value +- on_off_transition_time = json_payload.at("value").get(); ++ on_off_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9664,7 +9664,7 @@ static void uic_mqtt_dotdot_on_level_on_level_attribute_update( + } + + +- int8_t on_level = {}; ++ uint8_t on_level = {}; + + nlohmann::json json_payload; + try { +@@ -9677,7 +9677,7 @@ static void uic_mqtt_dotdot_on_level_on_level_attribute_update( + return; + } + // Start parsing value +- on_level = json_payload.at("value").get(); ++ on_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -9740,7 +9740,7 @@ static void uic_mqtt_dotdot_on_level_on_transition_time_attribute_update( + } + + +- int16_t on_transition_time = {}; ++ uint16_t on_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9753,7 +9753,7 @@ static void uic_mqtt_dotdot_on_level_on_transition_time_attribute_update( + return; + } + // Start parsing value +- on_transition_time = json_payload.at("value").get(); ++ on_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9816,7 +9816,7 @@ static void uic_mqtt_dotdot_on_level_off_transition_time_attribute_update( + } + + +- int16_t off_transition_time = {}; ++ uint16_t off_transition_time = {}; + + nlohmann::json json_payload; + try { +@@ -9829,7 +9829,7 @@ static void uic_mqtt_dotdot_on_level_off_transition_time_attribute_update( + return; + } + // Start parsing value +- off_transition_time = json_payload.at("value").get(); ++ off_transition_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -9892,7 +9892,7 @@ static void uic_mqtt_dotdot_on_level_default_move_rate_attribute_update( + } + + +- int16_t default_move_rate = {}; ++ uint16_t default_move_rate = {}; + + nlohmann::json json_payload; + try { +@@ -9905,7 +9905,7 @@ static void uic_mqtt_dotdot_on_level_default_move_rate_attribute_update( + return; + } + // Start parsing value +- default_move_rate = json_payload.at("value").get(); ++ default_move_rate = json_payload.at("value").get(); + + // End parsing value + } +@@ -9968,7 +9968,7 @@ static void uic_mqtt_dotdot_on_level_start_up_current_level_attribute_update( + } + + +- int8_t start_up_current_level = {}; ++ uint8_t start_up_current_level = {}; + + nlohmann::json json_payload; + try { +@@ -9981,7 +9981,7 @@ static void uic_mqtt_dotdot_on_level_start_up_current_level_attribute_update( + return; + } + // Start parsing value +- start_up_current_level = json_payload.at("value").get(); ++ start_up_current_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -10184,7 +10184,7 @@ static void uic_mqtt_dotdot_on_alarms_alarm_count_attribute_update( + } + + +- int16_t alarm_count = {}; ++ uint16_t alarm_count = {}; + + nlohmann::json json_payload; + try { +@@ -10197,7 +10197,7 @@ static void uic_mqtt_dotdot_on_alarms_alarm_count_attribute_update( + return; + } + // Start parsing value +- alarm_count = json_payload.at("value").get(); ++ alarm_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -10305,7 +10305,7 @@ static void uic_mqtt_dotdot_on_time_time_attribute_update( + } + + +- uint8_t time = {}; ++ uint32_t time = {}; + + nlohmann::json json_payload; + try { +@@ -10318,7 +10318,7 @@ static void uic_mqtt_dotdot_on_time_time_attribute_update( + return; + } + // Start parsing value +- time = json_payload.at("value").get(); ++ time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10533,7 +10533,7 @@ static void uic_mqtt_dotdot_on_time_dst_start_attribute_update( + } + + +- int32_t dst_start = {}; ++ uint32_t dst_start = {}; + + nlohmann::json json_payload; + try { +@@ -10546,7 +10546,7 @@ static void uic_mqtt_dotdot_on_time_dst_start_attribute_update( + return; + } + // Start parsing value +- dst_start = json_payload.at("value").get(); ++ dst_start = json_payload.at("value").get(); + + // End parsing value + } +@@ -10609,7 +10609,7 @@ static void uic_mqtt_dotdot_on_time_dst_end_attribute_update( + } + + +- int32_t dst_end = {}; ++ uint32_t dst_end = {}; + + nlohmann::json json_payload; + try { +@@ -10622,7 +10622,7 @@ static void uic_mqtt_dotdot_on_time_dst_end_attribute_update( + return; + } + // Start parsing value +- dst_end = json_payload.at("value").get(); ++ dst_end = json_payload.at("value").get(); + + // End parsing value + } +@@ -10761,7 +10761,7 @@ static void uic_mqtt_dotdot_on_time_standard_time_attribute_update( + } + + +- int32_t standard_time = {}; ++ uint32_t standard_time = {}; + + nlohmann::json json_payload; + try { +@@ -10774,7 +10774,7 @@ static void uic_mqtt_dotdot_on_time_standard_time_attribute_update( + return; + } + // Start parsing value +- standard_time = json_payload.at("value").get(); ++ standard_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10837,7 +10837,7 @@ static void uic_mqtt_dotdot_on_time_local_time_attribute_update( + } + + +- int32_t local_time = {}; ++ uint32_t local_time = {}; + + nlohmann::json json_payload; + try { +@@ -10850,7 +10850,7 @@ static void uic_mqtt_dotdot_on_time_local_time_attribute_update( + return; + } + // Start parsing value +- local_time = json_payload.at("value").get(); ++ local_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10913,7 +10913,7 @@ static void uic_mqtt_dotdot_on_time_last_set_time_attribute_update( + } + + +- uint8_t last_set_time = {}; ++ uint32_t last_set_time = {}; + + nlohmann::json json_payload; + try { +@@ -10926,7 +10926,7 @@ static void uic_mqtt_dotdot_on_time_last_set_time_attribute_update( + return; + } + // Start parsing value +- last_set_time = json_payload.at("value").get(); ++ last_set_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -10989,7 +10989,7 @@ static void uic_mqtt_dotdot_on_time_valid_until_time_attribute_update( + } + + +- uint8_t valid_until_time = {}; ++ uint32_t valid_until_time = {}; + + nlohmann::json json_payload; + try { +@@ -11002,7 +11002,7 @@ static void uic_mqtt_dotdot_on_time_valid_until_time_attribute_update( + return; + } + // Start parsing value +- valid_until_time = json_payload.at("value").get(); ++ valid_until_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -11179,7 +11179,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_attribute_update( + } + + +- int32_t check_in_interval = {}; ++ uint32_t check_in_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11192,7 +11192,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_attribute_update( + return; + } + // Start parsing value +- check_in_interval = json_payload.at("value").get(); ++ check_in_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11255,7 +11255,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_attribute_update( + } + + +- int32_t long_poll_interval = {}; ++ uint32_t long_poll_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11268,7 +11268,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_attribute_update( + return; + } + // Start parsing value +- long_poll_interval = json_payload.at("value").get(); ++ long_poll_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11331,7 +11331,7 @@ static void uic_mqtt_dotdot_on_poll_control_short_poll_interval_attribute_update + } + + +- int16_t short_poll_interval = {}; ++ uint16_t short_poll_interval = {}; + + nlohmann::json json_payload; + try { +@@ -11344,7 +11344,7 @@ static void uic_mqtt_dotdot_on_poll_control_short_poll_interval_attribute_update + return; + } + // Start parsing value +- short_poll_interval = json_payload.at("value").get(); ++ short_poll_interval = json_payload.at("value").get(); + + // End parsing value + } +@@ -11407,7 +11407,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_attribute_update( + } + + +- int16_t fast_poll_timeout = {}; ++ uint16_t fast_poll_timeout = {}; + + nlohmann::json json_payload; + try { +@@ -11420,7 +11420,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_attribute_update( + return; + } + // Start parsing value +- fast_poll_timeout = json_payload.at("value").get(); ++ fast_poll_timeout = json_payload.at("value").get(); + + // End parsing value + } +@@ -11483,7 +11483,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_min_attribute_upda + } + + +- int32_t check_in_interval_min = {}; ++ uint32_t check_in_interval_min = {}; + + nlohmann::json json_payload; + try { +@@ -11496,7 +11496,7 @@ static void uic_mqtt_dotdot_on_poll_control_check_in_interval_min_attribute_upda + return; + } + // Start parsing value +- check_in_interval_min = json_payload.at("value").get(); ++ check_in_interval_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -11559,7 +11559,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_min_attribute_upd + } + + +- int32_t long_poll_interval_min = {}; ++ uint32_t long_poll_interval_min = {}; + + nlohmann::json json_payload; + try { +@@ -11572,7 +11572,7 @@ static void uic_mqtt_dotdot_on_poll_control_long_poll_interval_min_attribute_upd + return; + } + // Start parsing value +- long_poll_interval_min = json_payload.at("value").get(); ++ long_poll_interval_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -11635,7 +11635,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_max_attribute_upda + } + + +- int16_t fast_poll_timeout_max = {}; ++ uint16_t fast_poll_timeout_max = {}; + + nlohmann::json json_payload; + try { +@@ -11648,7 +11648,7 @@ static void uic_mqtt_dotdot_on_poll_control_fast_poll_timeout_max_attribute_upda + return; + } + // Start parsing value +- fast_poll_timeout_max = json_payload.at("value").get(); ++ fast_poll_timeout_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -11799,7 +11799,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_physical_closed_limit_attribu + } + + +- int16_t physical_closed_limit = {}; ++ uint16_t physical_closed_limit = {}; + + nlohmann::json json_payload; + try { +@@ -11812,7 +11812,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_physical_closed_limit_attribu + return; + } + // Start parsing value +- physical_closed_limit = json_payload.at("value").get(); ++ physical_closed_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -11875,7 +11875,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_motor_step_size_attribute_upd + } + + +- int8_t motor_step_size = {}; ++ uint8_t motor_step_size = {}; + + nlohmann::json json_payload; + try { +@@ -11888,7 +11888,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_motor_step_size_attribute_upd + return; + } + // Start parsing value +- motor_step_size = json_payload.at("value").get(); ++ motor_step_size = json_payload.at("value").get(); + + // End parsing value + } +@@ -12027,7 +12027,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_closed_limit_attribute_update + } + + +- int16_t closed_limit = {}; ++ uint16_t closed_limit = {}; + + nlohmann::json json_payload; + try { +@@ -12040,7 +12040,7 @@ static void uic_mqtt_dotdot_on_shade_configuration_closed_limit_attribute_update + return; + } + // Start parsing value +- closed_limit = json_payload.at("value").get(); ++ closed_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -12630,7 +12630,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_open_events_attribute_update( + } + + +- int32_t door_open_events = {}; ++ uint32_t door_open_events = {}; + + nlohmann::json json_payload; + try { +@@ -12643,7 +12643,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_open_events_attribute_update( + return; + } + // Start parsing value +- door_open_events = json_payload.at("value").get(); ++ door_open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -12706,7 +12706,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_closed_events_attribute_update( + } + + +- int32_t door_closed_events = {}; ++ uint32_t door_closed_events = {}; + + nlohmann::json json_payload; + try { +@@ -12719,7 +12719,7 @@ static void uic_mqtt_dotdot_on_door_lock_door_closed_events_attribute_update( + return; + } + // Start parsing value +- door_closed_events = json_payload.at("value").get(); ++ door_closed_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -12782,7 +12782,7 @@ static void uic_mqtt_dotdot_on_door_lock_open_period_attribute_update( + } + + +- int16_t open_period = {}; ++ uint16_t open_period = {}; + + nlohmann::json json_payload; + try { +@@ -12795,7 +12795,7 @@ static void uic_mqtt_dotdot_on_door_lock_open_period_attribute_update( + return; + } + // Start parsing value +- open_period = json_payload.at("value").get(); ++ open_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -12858,7 +12858,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_log_records_supported_attribu + } + + +- int16_t number_of_log_records_supported = {}; ++ uint16_t number_of_log_records_supported = {}; + + nlohmann::json json_payload; + try { +@@ -12871,7 +12871,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_log_records_supported_attribu + return; + } + // Start parsing value +- number_of_log_records_supported = json_payload.at("value").get(); ++ number_of_log_records_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -12934,7 +12934,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_total_users_supported_attribu + } + + +- int16_t number_of_total_users_supported = {}; ++ uint16_t number_of_total_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -12947,7 +12947,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_total_users_supported_attribu + return; + } + // Start parsing value +- number_of_total_users_supported = json_payload.at("value").get(); ++ number_of_total_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13010,7 +13010,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_pin_users_supported_attribute + } + + +- int16_t number_of_pin_users_supported = {}; ++ uint16_t number_of_pin_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13023,7 +13023,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_pin_users_supported_attribute + return; + } + // Start parsing value +- number_of_pin_users_supported = json_payload.at("value").get(); ++ number_of_pin_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13086,7 +13086,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_rfid_users_supported_attribut + } + + +- int16_t number_of_rfid_users_supported = {}; ++ uint16_t number_of_rfid_users_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13099,7 +13099,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_rfid_users_supported_attribut + return; + } + // Start parsing value +- number_of_rfid_users_supported = json_payload.at("value").get(); ++ number_of_rfid_users_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13162,7 +13162,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_week_day_schedules_supported_ + } + + +- int8_t number_of_week_day_schedules_supported_per_user = {}; ++ uint8_t number_of_week_day_schedules_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13175,7 +13175,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_week_day_schedules_supported_ + return; + } + // Start parsing value +- number_of_week_day_schedules_supported_per_user = json_payload.at("value").get(); ++ number_of_week_day_schedules_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13238,7 +13238,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_year_day_schedules_supported_ + } + + +- int8_t number_of_year_day_schedules_supported_per_user = {}; ++ uint8_t number_of_year_day_schedules_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13251,7 +13251,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_year_day_schedules_supported_ + return; + } + // Start parsing value +- number_of_year_day_schedules_supported_per_user = json_payload.at("value").get(); ++ number_of_year_day_schedules_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13314,7 +13314,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_holiday_schedules_supported_a + } + + +- int8_t number_of_holiday_schedules_supported = {}; ++ uint8_t number_of_holiday_schedules_supported = {}; + + nlohmann::json json_payload; + try { +@@ -13327,7 +13327,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_holiday_schedules_supported_a + return; + } + // Start parsing value +- number_of_holiday_schedules_supported = json_payload.at("value").get(); ++ number_of_holiday_schedules_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -13390,7 +13390,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_pin_code_length_attribute_update( + } + + +- int8_t max_pin_code_length = {}; ++ uint8_t max_pin_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13403,7 +13403,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_pin_code_length_attribute_update( + return; + } + // Start parsing value +- max_pin_code_length = json_payload.at("value").get(); ++ max_pin_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13466,7 +13466,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_pin_code_length_attribute_update( + } + + +- int8_t min_pin_code_length = {}; ++ uint8_t min_pin_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13479,7 +13479,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_pin_code_length_attribute_update( + return; + } + // Start parsing value +- min_pin_code_length = json_payload.at("value").get(); ++ min_pin_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13542,7 +13542,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_rfid_code_length_attribute_update( + } + + +- int8_t max_rfid_code_length = {}; ++ uint8_t max_rfid_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13555,7 +13555,7 @@ static void uic_mqtt_dotdot_on_door_lock_max_rfid_code_length_attribute_update( + return; + } + // Start parsing value +- max_rfid_code_length = json_payload.at("value").get(); ++ max_rfid_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13618,7 +13618,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_rfid_code_length_attribute_update( + } + + +- int8_t min_rfid_code_length = {}; ++ uint8_t min_rfid_code_length = {}; + + nlohmann::json json_payload; + try { +@@ -13631,7 +13631,7 @@ static void uic_mqtt_dotdot_on_door_lock_min_rfid_code_length_attribute_update( + return; + } + // Start parsing value +- min_rfid_code_length = json_payload.at("value").get(); ++ min_rfid_code_length = json_payload.at("value").get(); + + // End parsing value + } +@@ -13770,7 +13770,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_credentials_supported_per_use + } + + +- int8_t number_of_credentials_supported_per_user = {}; ++ uint8_t number_of_credentials_supported_per_user = {}; + + nlohmann::json json_payload; + try { +@@ -13783,7 +13783,7 @@ static void uic_mqtt_dotdot_on_door_lock_number_of_credentials_supported_per_use + return; + } + // Start parsing value +- number_of_credentials_supported_per_user = json_payload.at("value").get(); ++ number_of_credentials_supported_per_user = json_payload.at("value").get(); + + // End parsing value + } +@@ -13998,7 +13998,7 @@ static void uic_mqtt_dotdot_on_door_lock_led_settings_attribute_update( + } + + +- int8_t led_settings = {}; ++ uint8_t led_settings = {}; + + nlohmann::json json_payload; + try { +@@ -14011,7 +14011,7 @@ static void uic_mqtt_dotdot_on_door_lock_led_settings_attribute_update( + return; + } + // Start parsing value +- led_settings = json_payload.at("value").get(); ++ led_settings = json_payload.at("value").get(); + + // End parsing value + } +@@ -14074,7 +14074,7 @@ static void uic_mqtt_dotdot_on_door_lock_auto_relock_time_attribute_update( + } + + +- int32_t auto_relock_time = {}; ++ uint32_t auto_relock_time = {}; + + nlohmann::json json_payload; + try { +@@ -14087,7 +14087,7 @@ static void uic_mqtt_dotdot_on_door_lock_auto_relock_time_attribute_update( + return; + } + // Start parsing value +- auto_relock_time = json_payload.at("value").get(); ++ auto_relock_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -14150,7 +14150,7 @@ static void uic_mqtt_dotdot_on_door_lock_sound_volume_attribute_update( + } + + +- int8_t sound_volume = {}; ++ uint8_t sound_volume = {}; + + nlohmann::json json_payload; + try { +@@ -14163,7 +14163,7 @@ static void uic_mqtt_dotdot_on_door_lock_sound_volume_attribute_update( + return; + } + // Start parsing value +- sound_volume = json_payload.at("value").get(); ++ sound_volume = json_payload.at("value").get(); + + // End parsing value + } +@@ -14842,7 +14842,7 @@ static void uic_mqtt_dotdot_on_door_lock_wrong_code_entry_limit_attribute_update + } + + +- int8_t wrong_code_entry_limit = {}; ++ uint8_t wrong_code_entry_limit = {}; + + nlohmann::json json_payload; + try { +@@ -14855,7 +14855,7 @@ static void uic_mqtt_dotdot_on_door_lock_wrong_code_entry_limit_attribute_update + return; + } + // Start parsing value +- wrong_code_entry_limit = json_payload.at("value").get(); ++ wrong_code_entry_limit = json_payload.at("value").get(); + + // End parsing value + } +@@ -14918,7 +14918,7 @@ static void uic_mqtt_dotdot_on_door_lock_user_code_temporary_disable_time_attrib + } + + +- int8_t user_code_temporary_disable_time = {}; ++ uint8_t user_code_temporary_disable_time = {}; + + nlohmann::json json_payload; + try { +@@ -14931,7 +14931,7 @@ static void uic_mqtt_dotdot_on_door_lock_user_code_temporary_disable_time_attrib + return; + } + // Start parsing value +- user_code_temporary_disable_time = json_payload.at("value").get(); ++ user_code_temporary_disable_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -15230,7 +15230,7 @@ static void uic_mqtt_dotdot_on_door_lock_expiring_user_timeout_attribute_update( + } + + +- int16_t expiring_user_timeout = {}; ++ uint16_t expiring_user_timeout = {}; + + nlohmann::json json_payload; + try { +@@ -15243,7 +15243,7 @@ static void uic_mqtt_dotdot_on_door_lock_expiring_user_timeout_attribute_update( + return; + } + // Start parsing value +- expiring_user_timeout = json_payload.at("value").get(); ++ expiring_user_timeout = json_payload.at("value").get(); + + // End parsing value + } +@@ -16505,7 +16505,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_lift_attrib + } + + +- int16_t physical_closed_limit_lift = {}; ++ uint16_t physical_closed_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16518,7 +16518,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_lift_attrib + return; + } + // Start parsing value +- physical_closed_limit_lift = json_payload.at("value").get(); ++ physical_closed_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16581,7 +16581,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_tilt_attrib + } + + +- int16_t physical_closed_limit_tilt = {}; ++ uint16_t physical_closed_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16594,7 +16594,7 @@ static void uic_mqtt_dotdot_on_window_covering_physical_closed_limit_tilt_attrib + return; + } + // Start parsing value +- physical_closed_limit_tilt = json_payload.at("value").get(); ++ physical_closed_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -16657,7 +16657,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_attribute_u + } + + +- int16_t current_position_lift = {}; ++ uint16_t current_position_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16670,7 +16670,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_attribute_u + return; + } + // Start parsing value +- current_position_lift = json_payload.at("value").get(); ++ current_position_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16733,7 +16733,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_attribute_u + } + + +- int16_t current_position_tilt = {}; ++ uint16_t current_position_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16746,7 +16746,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_attribute_u + return; + } + // Start parsing value +- current_position_tilt = json_payload.at("value").get(); ++ current_position_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -16809,7 +16809,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_lift_attribu + } + + +- int16_t number_of_actuations_lift = {}; ++ uint16_t number_of_actuations_lift = {}; + + nlohmann::json json_payload; + try { +@@ -16822,7 +16822,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_lift_attribu + return; + } + // Start parsing value +- number_of_actuations_lift = json_payload.at("value").get(); ++ number_of_actuations_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -16885,7 +16885,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_tilt_attribu + } + + +- int16_t number_of_actuations_tilt = {}; ++ uint16_t number_of_actuations_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -16898,7 +16898,7 @@ static void uic_mqtt_dotdot_on_window_covering_number_of_actuations_tilt_attribu + return; + } + // Start parsing value +- number_of_actuations_tilt = json_payload.at("value").get(); ++ number_of_actuations_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17037,7 +17037,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_percentage_ + } + + +- int8_t current_position_lift_percentage = {}; ++ uint8_t current_position_lift_percentage = {}; + + nlohmann::json json_payload; + try { +@@ -17050,7 +17050,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_lift_percentage_ + return; + } + // Start parsing value +- current_position_lift_percentage = json_payload.at("value").get(); ++ current_position_lift_percentage = json_payload.at("value").get(); + + // End parsing value + } +@@ -17113,7 +17113,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_percentage_ + } + + +- int8_t current_position_tilt_percentage = {}; ++ uint8_t current_position_tilt_percentage = {}; + + nlohmann::json json_payload; + try { +@@ -17126,7 +17126,7 @@ static void uic_mqtt_dotdot_on_window_covering_current_position_tilt_percentage_ + return; + } + // Start parsing value +- current_position_tilt_percentage = json_payload.at("value").get(); ++ current_position_tilt_percentage = json_payload.at("value").get(); + + // End parsing value + } +@@ -17189,7 +17189,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_lift_attribu + } + + +- int16_t installed_open_limit_lift = {}; ++ uint16_t installed_open_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17202,7 +17202,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_lift_attribu + return; + } + // Start parsing value +- installed_open_limit_lift = json_payload.at("value").get(); ++ installed_open_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17265,7 +17265,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_lift_attri + } + + +- int16_t installed_closed_limit_lift = {}; ++ uint16_t installed_closed_limit_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17278,7 +17278,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_lift_attri + return; + } + // Start parsing value +- installed_closed_limit_lift = json_payload.at("value").get(); ++ installed_closed_limit_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17341,7 +17341,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_tilt_attribu + } + + +- int16_t installed_open_limit_tilt = {}; ++ uint16_t installed_open_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -17354,7 +17354,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_open_limit_tilt_attribu + return; + } + // Start parsing value +- installed_open_limit_tilt = json_payload.at("value").get(); ++ installed_open_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17417,7 +17417,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_tilt_attri + } + + +- int16_t installed_closed_limit_tilt = {}; ++ uint16_t installed_closed_limit_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -17430,7 +17430,7 @@ static void uic_mqtt_dotdot_on_window_covering_installed_closed_limit_tilt_attri + return; + } + // Start parsing value +- installed_closed_limit_tilt = json_payload.at("value").get(); ++ installed_closed_limit_tilt = json_payload.at("value").get(); + + // End parsing value + } +@@ -17493,7 +17493,7 @@ static void uic_mqtt_dotdot_on_window_covering_velocity_lift_attribute_update( + } + + +- int16_t velocity_lift = {}; ++ uint16_t velocity_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17506,7 +17506,7 @@ static void uic_mqtt_dotdot_on_window_covering_velocity_lift_attribute_update( + return; + } + // Start parsing value +- velocity_lift = json_payload.at("value").get(); ++ velocity_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17569,7 +17569,7 @@ static void uic_mqtt_dotdot_on_window_covering_acceleration_time_lift_attribute_ + } + + +- int16_t acceleration_time_lift = {}; ++ uint16_t acceleration_time_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17582,7 +17582,7 @@ static void uic_mqtt_dotdot_on_window_covering_acceleration_time_lift_attribute_ + return; + } + // Start parsing value +- acceleration_time_lift = json_payload.at("value").get(); ++ acceleration_time_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17645,7 +17645,7 @@ static void uic_mqtt_dotdot_on_window_covering_deceleration_time_lift_attribute_ + } + + +- int16_t deceleration_time_lift = {}; ++ uint16_t deceleration_time_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17658,7 +17658,7 @@ static void uic_mqtt_dotdot_on_window_covering_deceleration_time_lift_attribute_ + return; + } + // Start parsing value +- deceleration_time_lift = json_payload.at("value").get(); ++ deceleration_time_lift = json_payload.at("value").get(); + + // End parsing value + } +@@ -17797,7 +17797,7 @@ static void uic_mqtt_dotdot_on_window_covering_intermediate_setpoints_lift_attri + } + + +- uint8_t intermediate_setpoints_lift = {}; ++ const char* intermediate_setpoints_lift = {}; + + nlohmann::json json_payload; + try { +@@ -17873,7 +17873,7 @@ static void uic_mqtt_dotdot_on_window_covering_intermediate_setpoints_tilt_attri + } + + +- uint8_t intermediate_setpoints_tilt = {}; ++ const char* intermediate_setpoints_tilt = {}; + + nlohmann::json json_payload; + try { +@@ -18382,7 +18382,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_events_attribute_update( + } + + +- int16_t open_events = {}; ++ uint16_t open_events = {}; + + nlohmann::json json_payload; + try { +@@ -18395,7 +18395,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_events_attribute_update( + return; + } + // Start parsing value +- open_events = json_payload.at("value").get(); ++ open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18458,7 +18458,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_events_attribute_update( + } + + +- int16_t close_events = {}; ++ uint16_t close_events = {}; + + nlohmann::json json_payload; + try { +@@ -18471,7 +18471,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_events_attribute_update( + return; + } + // Start parsing value +- close_events = json_payload.at("value").get(); ++ close_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18534,7 +18534,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_open_events_attribute_upd + } + + +- int16_t command_open_events = {}; ++ uint16_t command_open_events = {}; + + nlohmann::json json_payload; + try { +@@ -18547,7 +18547,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_open_events_attribute_upd + return; + } + // Start parsing value +- command_open_events = json_payload.at("value").get(); ++ command_open_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18610,7 +18610,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_close_events_attribute_up + } + + +- int16_t command_close_events = {}; ++ uint16_t command_close_events = {}; + + nlohmann::json json_payload; + try { +@@ -18623,7 +18623,7 @@ static void uic_mqtt_dotdot_on_barrier_control_command_close_events_attribute_up + return; + } + // Start parsing value +- command_close_events = json_payload.at("value").get(); ++ command_close_events = json_payload.at("value").get(); + + // End parsing value + } +@@ -18686,7 +18686,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_period_attribute_update( + } + + +- int16_t open_period = {}; ++ uint16_t open_period = {}; + + nlohmann::json json_payload; + try { +@@ -18699,7 +18699,7 @@ static void uic_mqtt_dotdot_on_barrier_control_open_period_attribute_update( + return; + } + // Start parsing value +- open_period = json_payload.at("value").get(); ++ open_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -18762,7 +18762,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_period_attribute_update( + } + + +- int16_t close_period = {}; ++ uint16_t close_period = {}; + + nlohmann::json json_payload; + try { +@@ -18775,7 +18775,7 @@ static void uic_mqtt_dotdot_on_barrier_control_close_period_attribute_update( + return; + } + // Start parsing value +- close_period = json_payload.at("value").get(); ++ close_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -18838,7 +18838,7 @@ static void uic_mqtt_dotdot_on_barrier_control_barrier_position_attribute_update + } + + +- int8_t barrier_position = {}; ++ uint8_t barrier_position = {}; + + nlohmann::json json_payload; + try { +@@ -18851,7 +18851,7 @@ static void uic_mqtt_dotdot_on_barrier_control_barrier_position_attribute_update + return; + } + // Start parsing value +- barrier_position = json_payload.at("value").get(); ++ barrier_position = json_payload.at("value").get(); + + // End parsing value + } +@@ -19121,7 +19121,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_speed_attribut + } + + +- int16_t max_speed = {}; ++ uint16_t max_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19134,7 +19134,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_speed_attribut + return; + } + // Start parsing value +- max_speed = json_payload.at("value").get(); ++ max_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19197,7 +19197,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_flow_attribute + } + + +- int16_t max_flow = {}; ++ uint16_t max_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19210,7 +19210,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_flow_attribute + return; + } + // Start parsing value +- max_flow = json_payload.at("value").get(); ++ max_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -19577,7 +19577,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_speed_at + } + + +- int16_t min_const_speed = {}; ++ uint16_t min_const_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19590,7 +19590,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_speed_at + return; + } + // Start parsing value +- min_const_speed = json_payload.at("value").get(); ++ min_const_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19653,7 +19653,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_speed_at + } + + +- int16_t max_const_speed = {}; ++ uint16_t max_const_speed = {}; + + nlohmann::json json_payload; + try { +@@ -19666,7 +19666,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_speed_at + return; + } + // Start parsing value +- max_const_speed = json_payload.at("value").get(); ++ max_const_speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -19729,7 +19729,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_flow_att + } + + +- int16_t min_const_flow = {}; ++ uint16_t min_const_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19742,7 +19742,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_min_const_flow_att + return; + } + // Start parsing value +- min_const_flow = json_payload.at("value").get(); ++ min_const_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -19805,7 +19805,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_flow_att + } + + +- int16_t max_const_flow = {}; ++ uint16_t max_const_flow = {}; + + nlohmann::json json_payload; + try { +@@ -19818,7 +19818,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_max_const_flow_att + return; + } + // Start parsing value +- max_const_flow = json_payload.at("value").get(); ++ max_const_flow = json_payload.at("value").get(); + + // End parsing value + } +@@ -20353,7 +20353,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_speed_attribute_up + } + + +- int16_t speed = {}; ++ uint16_t speed = {}; + + nlohmann::json json_payload; + try { +@@ -20366,7 +20366,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_speed_attribute_up + return; + } + // Start parsing value +- speed = json_payload.at("value").get(); ++ speed = json_payload.at("value").get(); + + // End parsing value + } +@@ -20429,7 +20429,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_running_h + } + + +- int32_t lifetime_running_hours = {}; ++ uint32_t lifetime_running_hours = {}; + + nlohmann::json json_payload; + try { +@@ -20442,7 +20442,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_running_h + return; + } + // Start parsing value +- lifetime_running_hours = json_payload.at("value").get(); ++ lifetime_running_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -20505,7 +20505,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_power_attribute_up + } + + +- int32_t power = {}; ++ uint32_t power = {}; + + nlohmann::json json_payload; + try { +@@ -20518,7 +20518,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_power_attribute_up + return; + } + // Start parsing value +- power = json_payload.at("value").get(); ++ power = json_payload.at("value").get(); + + // End parsing value + } +@@ -20581,7 +20581,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_energy_co + } + + +- int32_t lifetime_energy_consumed = {}; ++ uint32_t lifetime_energy_consumed = {}; + + nlohmann::json json_payload; + try { +@@ -20594,7 +20594,7 @@ static void uic_mqtt_dotdot_on_pump_configuration_and_control_lifetime_energy_co + return; + } + // Start parsing value +- lifetime_energy_consumed = json_payload.at("value").get(); ++ lifetime_energy_consumed = json_payload.at("value").get(); + + // End parsing value + } +@@ -21702,7 +21702,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_cooling_demand_attribute_update( + } + + +- int8_t pi_cooling_demand = {}; ++ uint8_t pi_cooling_demand = {}; + + nlohmann::json json_payload; + try { +@@ -21715,7 +21715,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_cooling_demand_attribute_update( + return; + } + // Start parsing value +- pi_cooling_demand = json_payload.at("value").get(); ++ pi_cooling_demand = json_payload.at("value").get(); + + // End parsing value + } +@@ -21778,7 +21778,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_heating_demand_attribute_update( + } + + +- int8_t pi_heating_demand = {}; ++ uint8_t pi_heating_demand = {}; + + nlohmann::json json_payload; + try { +@@ -21791,7 +21791,7 @@ static void uic_mqtt_dotdot_on_thermostat_pi_heating_demand_attribute_update( + return; + } + // Start parsing value +- pi_heating_demand = json_payload.at("value").get(); ++ pi_heating_demand = json_payload.at("value").get(); + + // End parsing value + } +@@ -23178,7 +23178,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_weekly_transitions_attribute + } + + +- int8_t number_of_weekly_transitions = {}; ++ uint8_t number_of_weekly_transitions = {}; + + nlohmann::json json_payload; + try { +@@ -23191,7 +23191,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_weekly_transitions_attribute + return; + } + // Start parsing value +- number_of_weekly_transitions = json_payload.at("value").get(); ++ number_of_weekly_transitions = json_payload.at("value").get(); + + // End parsing value + } +@@ -23254,7 +23254,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_daily_transitions_attribute_ + } + + +- int8_t number_of_daily_transitions = {}; ++ uint8_t number_of_daily_transitions = {}; + + nlohmann::json json_payload; + try { +@@ -23267,7 +23267,7 @@ static void uic_mqtt_dotdot_on_thermostat_number_of_daily_transitions_attribute_ + return; + } + // Start parsing value +- number_of_daily_transitions = json_payload.at("value").get(); ++ number_of_daily_transitions = json_payload.at("value").get(); + + // End parsing value + } +@@ -23414,7 +23414,7 @@ static void uic_mqtt_dotdot_on_thermostat_temperature_setpoint_hold_duration_att + } + + +- int16_t temperature_setpoint_hold_duration = {}; ++ uint16_t temperature_setpoint_hold_duration = {}; + + nlohmann::json json_payload; + try { +@@ -23427,7 +23427,7 @@ static void uic_mqtt_dotdot_on_thermostat_temperature_setpoint_hold_duration_att + return; + } + // Start parsing value +- temperature_setpoint_hold_duration = json_payload.at("value").get(); ++ temperature_setpoint_hold_duration = json_payload.at("value").get(); + + // End parsing value + } +@@ -23802,7 +23802,7 @@ static void uic_mqtt_dotdot_on_thermostat_setpoint_change_source_timestamp_attri + } + + +- uint8_t setpoint_change_source_timestamp = {}; ++ uint32_t setpoint_change_source_timestamp = {}; + + nlohmann::json json_payload; + try { +@@ -23815,7 +23815,7 @@ static void uic_mqtt_dotdot_on_thermostat_setpoint_change_source_timestamp_attri + return; + } + // Start parsing value +- setpoint_change_source_timestamp = json_payload.at("value").get(); ++ setpoint_change_source_timestamp = json_payload.at("value").get(); + + // End parsing value + } +@@ -23878,7 +23878,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_attribute_update( + } + + +- int8_t occupied_setback = {}; ++ uint8_t occupied_setback = {}; + + nlohmann::json json_payload; + try { +@@ -23891,7 +23891,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_attribute_update( + return; + } + // Start parsing value +- occupied_setback = json_payload.at("value").get(); ++ occupied_setback = json_payload.at("value").get(); + + // End parsing value + } +@@ -23954,7 +23954,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_min_attribute_update( + } + + +- int8_t occupied_setback_min = {}; ++ uint8_t occupied_setback_min = {}; + + nlohmann::json json_payload; + try { +@@ -23967,7 +23967,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_min_attribute_update( + return; + } + // Start parsing value +- occupied_setback_min = json_payload.at("value").get(); ++ occupied_setback_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -24030,7 +24030,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_max_attribute_update( + } + + +- int8_t occupied_setback_max = {}; ++ uint8_t occupied_setback_max = {}; + + nlohmann::json json_payload; + try { +@@ -24043,7 +24043,7 @@ static void uic_mqtt_dotdot_on_thermostat_occupied_setback_max_attribute_update( + return; + } + // Start parsing value +- occupied_setback_max = json_payload.at("value").get(); ++ occupied_setback_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -24106,7 +24106,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_attribute_update( + } + + +- int8_t unoccupied_setback = {}; ++ uint8_t unoccupied_setback = {}; + + nlohmann::json json_payload; + try { +@@ -24119,7 +24119,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_attribute_update( + return; + } + // Start parsing value +- unoccupied_setback = json_payload.at("value").get(); ++ unoccupied_setback = json_payload.at("value").get(); + + // End parsing value + } +@@ -24182,7 +24182,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_min_attribute_updat + } + + +- int8_t unoccupied_setback_min = {}; ++ uint8_t unoccupied_setback_min = {}; + + nlohmann::json json_payload; + try { +@@ -24195,7 +24195,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_min_attribute_updat + return; + } + // Start parsing value +- unoccupied_setback_min = json_payload.at("value").get(); ++ unoccupied_setback_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -24258,7 +24258,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_max_attribute_updat + } + + +- int8_t unoccupied_setback_max = {}; ++ uint8_t unoccupied_setback_max = {}; + + nlohmann::json json_payload; + try { +@@ -24271,7 +24271,7 @@ static void uic_mqtt_dotdot_on_thermostat_unoccupied_setback_max_attribute_updat + return; + } + // Start parsing value +- unoccupied_setback_max = json_payload.at("value").get(); ++ unoccupied_setback_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -24334,7 +24334,7 @@ static void uic_mqtt_dotdot_on_thermostat_emergency_heat_delta_attribute_update( + } + + +- int8_t emergency_heat_delta = {}; ++ uint8_t emergency_heat_delta = {}; + + nlohmann::json json_payload; + try { +@@ -24347,7 +24347,7 @@ static void uic_mqtt_dotdot_on_thermostat_emergency_heat_delta_attribute_update( + return; + } + // Start parsing value +- emergency_heat_delta = json_payload.at("value").get(); ++ emergency_heat_delta = json_payload.at("value").get(); + + // End parsing value + } +@@ -24494,7 +24494,7 @@ static void uic_mqtt_dotdot_on_thermostat_ac_capacity_attribute_update( + } + + +- int16_t ac_capacity = {}; ++ uint16_t ac_capacity = {}; + + nlohmann::json json_payload; + try { +@@ -24507,7 +24507,7 @@ static void uic_mqtt_dotdot_on_thermostat_ac_capacity_attribute_update( + return; + } + // Start parsing value +- ac_capacity = json_payload.at("value").get(); ++ ac_capacity = json_payload.at("value").get(); + + // End parsing value + } +@@ -25706,7 +25706,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_relative_humidity_attrib + } + + +- int8_t relative_humidity = {}; ++ uint8_t relative_humidity = {}; + + nlohmann::json json_payload; + try { +@@ -25719,7 +25719,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_relative_humidity_attrib + return; + } + // Start parsing value +- relative_humidity = json_payload.at("value").get(); ++ relative_humidity = json_payload.at("value").get(); + + // End parsing value + } +@@ -25782,7 +25782,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_cooling + } + + +- int8_t dehumidification_cooling = {}; ++ uint8_t dehumidification_cooling = {}; + + nlohmann::json json_payload; + try { +@@ -25795,7 +25795,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_cooling + return; + } + // Start parsing value +- dehumidification_cooling = json_payload.at("value").get(); ++ dehumidification_cooling = json_payload.at("value").get(); + + // End parsing value + } +@@ -25858,7 +25858,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_rh_dehumidification_setp + } + + +- int8_t rh_dehumidification_setpoint = {}; ++ uint8_t rh_dehumidification_setpoint = {}; + + nlohmann::json json_payload; + try { +@@ -25871,7 +25871,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_rh_dehumidification_setp + return; + } + // Start parsing value +- rh_dehumidification_setpoint = json_payload.at("value").get(); ++ rh_dehumidification_setpoint = json_payload.at("value").get(); + + // End parsing value + } +@@ -26102,7 +26102,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_hystere + } + + +- int8_t dehumidification_hysteresis = {}; ++ uint8_t dehumidification_hysteresis = {}; + + nlohmann::json json_payload; + try { +@@ -26115,7 +26115,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_hystere + return; + } + // Start parsing value +- dehumidification_hysteresis = json_payload.at("value").get(); ++ dehumidification_hysteresis = json_payload.at("value").get(); + + // End parsing value + } +@@ -26178,7 +26178,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_max_coo + } + + +- int8_t dehumidification_max_cool = {}; ++ uint8_t dehumidification_max_cool = {}; + + nlohmann::json json_payload; + try { +@@ -26191,7 +26191,7 @@ static void uic_mqtt_dotdot_on_dehumidification_control_dehumidification_max_coo + return; + } + // Start parsing value +- dehumidification_max_cool = json_payload.at("value").get(); ++ dehumidification_max_cool = json_payload.at("value").get(); + + // End parsing value + } +@@ -26787,7 +26787,7 @@ static void uic_mqtt_dotdot_on_color_control_current_hue_attribute_update( + } + + +- int8_t current_hue = {}; ++ uint8_t current_hue = {}; + + nlohmann::json json_payload; + try { +@@ -26800,7 +26800,7 @@ static void uic_mqtt_dotdot_on_color_control_current_hue_attribute_update( + return; + } + // Start parsing value +- current_hue = json_payload.at("value").get(); ++ current_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -26863,7 +26863,7 @@ static void uic_mqtt_dotdot_on_color_control_current_saturation_attribute_update + } + + +- int8_t current_saturation = {}; ++ uint8_t current_saturation = {}; + + nlohmann::json json_payload; + try { +@@ -26876,7 +26876,7 @@ static void uic_mqtt_dotdot_on_color_control_current_saturation_attribute_update + return; + } + // Start parsing value +- current_saturation = json_payload.at("value").get(); ++ current_saturation = json_payload.at("value").get(); + + // End parsing value + } +@@ -26939,7 +26939,7 @@ static void uic_mqtt_dotdot_on_color_control_remaining_time_attribute_update( + } + + +- int16_t remaining_time = {}; ++ uint16_t remaining_time = {}; + + nlohmann::json json_payload; + try { +@@ -26952,7 +26952,7 @@ static void uic_mqtt_dotdot_on_color_control_remaining_time_attribute_update( + return; + } + // Start parsing value +- remaining_time = json_payload.at("value").get(); ++ remaining_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -27015,7 +27015,7 @@ static void uic_mqtt_dotdot_on_color_control_currentx_attribute_update( + } + + +- int16_t currentx = {}; ++ uint16_t currentx = {}; + + nlohmann::json json_payload; + try { +@@ -27028,7 +27028,7 @@ static void uic_mqtt_dotdot_on_color_control_currentx_attribute_update( + return; + } + // Start parsing value +- currentx = json_payload.at("value").get(); ++ currentx = json_payload.at("value").get(); + + // End parsing value + } +@@ -27091,7 +27091,7 @@ static void uic_mqtt_dotdot_on_color_control_currenty_attribute_update( + } + + +- int16_t currenty = {}; ++ uint16_t currenty = {}; + + nlohmann::json json_payload; + try { +@@ -27104,7 +27104,7 @@ static void uic_mqtt_dotdot_on_color_control_currenty_attribute_update( + return; + } + // Start parsing value +- currenty = json_payload.at("value").get(); ++ currenty = json_payload.at("value").get(); + + // End parsing value + } +@@ -27327,7 +27327,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temperature_mireds_attribute_ + } + + +- int16_t color_temperature_mireds = {}; ++ uint16_t color_temperature_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -27340,7 +27340,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temperature_mireds_attribute_ + return; + } + // Start parsing value +- color_temperature_mireds = json_payload.at("value").get(); ++ color_temperature_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -27563,7 +27563,7 @@ static void uic_mqtt_dotdot_on_color_control_number_of_primaries_attribute_updat + } + + +- int8_t number_of_primaries = {}; ++ uint8_t number_of_primaries = {}; + + nlohmann::json json_payload; + try { +@@ -27576,7 +27576,7 @@ static void uic_mqtt_dotdot_on_color_control_number_of_primaries_attribute_updat + return; + } + // Start parsing value +- number_of_primaries = json_payload.at("value").get(); ++ number_of_primaries = json_payload.at("value").get(); + + // End parsing value + } +@@ -27639,7 +27639,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1x_attribute_update( + } + + +- int16_t primary1x = {}; ++ uint16_t primary1x = {}; + + nlohmann::json json_payload; + try { +@@ -27652,7 +27652,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1x_attribute_update( + return; + } + // Start parsing value +- primary1x = json_payload.at("value").get(); ++ primary1x = json_payload.at("value").get(); + + // End parsing value + } +@@ -27715,7 +27715,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1y_attribute_update( + } + + +- int16_t primary1y = {}; ++ uint16_t primary1y = {}; + + nlohmann::json json_payload; + try { +@@ -27728,7 +27728,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1y_attribute_update( + return; + } + // Start parsing value +- primary1y = json_payload.at("value").get(); ++ primary1y = json_payload.at("value").get(); + + // End parsing value + } +@@ -27791,7 +27791,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1_intensity_attribute_update + } + + +- int8_t primary1_intensity = {}; ++ uint8_t primary1_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -27804,7 +27804,7 @@ static void uic_mqtt_dotdot_on_color_control_primary1_intensity_attribute_update + return; + } + // Start parsing value +- primary1_intensity = json_payload.at("value").get(); ++ primary1_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -27867,7 +27867,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2x_attribute_update( + } + + +- int16_t primary2x = {}; ++ uint16_t primary2x = {}; + + nlohmann::json json_payload; + try { +@@ -27880,7 +27880,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2x_attribute_update( + return; + } + // Start parsing value +- primary2x = json_payload.at("value").get(); ++ primary2x = json_payload.at("value").get(); + + // End parsing value + } +@@ -27943,7 +27943,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2y_attribute_update( + } + + +- int16_t primary2y = {}; ++ uint16_t primary2y = {}; + + nlohmann::json json_payload; + try { +@@ -27956,7 +27956,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2y_attribute_update( + return; + } + // Start parsing value +- primary2y = json_payload.at("value").get(); ++ primary2y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28019,7 +28019,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2_intensity_attribute_update + } + + +- int8_t primary2_intensity = {}; ++ uint8_t primary2_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28032,7 +28032,7 @@ static void uic_mqtt_dotdot_on_color_control_primary2_intensity_attribute_update + return; + } + // Start parsing value +- primary2_intensity = json_payload.at("value").get(); ++ primary2_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28095,7 +28095,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3x_attribute_update( + } + + +- int16_t primary3x = {}; ++ uint16_t primary3x = {}; + + nlohmann::json json_payload; + try { +@@ -28108,7 +28108,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3x_attribute_update( + return; + } + // Start parsing value +- primary3x = json_payload.at("value").get(); ++ primary3x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28171,7 +28171,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3y_attribute_update( + } + + +- int16_t primary3y = {}; ++ uint16_t primary3y = {}; + + nlohmann::json json_payload; + try { +@@ -28184,7 +28184,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3y_attribute_update( + return; + } + // Start parsing value +- primary3y = json_payload.at("value").get(); ++ primary3y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28247,7 +28247,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3_intensity_attribute_update + } + + +- int8_t primary3_intensity = {}; ++ uint8_t primary3_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28260,7 +28260,7 @@ static void uic_mqtt_dotdot_on_color_control_primary3_intensity_attribute_update + return; + } + // Start parsing value +- primary3_intensity = json_payload.at("value").get(); ++ primary3_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28323,7 +28323,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4x_attribute_update( + } + + +- int16_t primary4x = {}; ++ uint16_t primary4x = {}; + + nlohmann::json json_payload; + try { +@@ -28336,7 +28336,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4x_attribute_update( + return; + } + // Start parsing value +- primary4x = json_payload.at("value").get(); ++ primary4x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28399,7 +28399,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4y_attribute_update( + } + + +- int16_t primary4y = {}; ++ uint16_t primary4y = {}; + + nlohmann::json json_payload; + try { +@@ -28412,7 +28412,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4y_attribute_update( + return; + } + // Start parsing value +- primary4y = json_payload.at("value").get(); ++ primary4y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28475,7 +28475,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4_intensity_attribute_update + } + + +- int8_t primary4_intensity = {}; ++ uint8_t primary4_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28488,7 +28488,7 @@ static void uic_mqtt_dotdot_on_color_control_primary4_intensity_attribute_update + return; + } + // Start parsing value +- primary4_intensity = json_payload.at("value").get(); ++ primary4_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28551,7 +28551,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5x_attribute_update( + } + + +- int16_t primary5x = {}; ++ uint16_t primary5x = {}; + + nlohmann::json json_payload; + try { +@@ -28564,7 +28564,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5x_attribute_update( + return; + } + // Start parsing value +- primary5x = json_payload.at("value").get(); ++ primary5x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28627,7 +28627,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5y_attribute_update( + } + + +- int16_t primary5y = {}; ++ uint16_t primary5y = {}; + + nlohmann::json json_payload; + try { +@@ -28640,7 +28640,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5y_attribute_update( + return; + } + // Start parsing value +- primary5y = json_payload.at("value").get(); ++ primary5y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28703,7 +28703,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5_intensity_attribute_update + } + + +- int8_t primary5_intensity = {}; ++ uint8_t primary5_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28716,7 +28716,7 @@ static void uic_mqtt_dotdot_on_color_control_primary5_intensity_attribute_update + return; + } + // Start parsing value +- primary5_intensity = json_payload.at("value").get(); ++ primary5_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -28779,7 +28779,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6x_attribute_update( + } + + +- int16_t primary6x = {}; ++ uint16_t primary6x = {}; + + nlohmann::json json_payload; + try { +@@ -28792,7 +28792,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6x_attribute_update( + return; + } + // Start parsing value +- primary6x = json_payload.at("value").get(); ++ primary6x = json_payload.at("value").get(); + + // End parsing value + } +@@ -28855,7 +28855,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6y_attribute_update( + } + + +- int16_t primary6y = {}; ++ uint16_t primary6y = {}; + + nlohmann::json json_payload; + try { +@@ -28868,7 +28868,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6y_attribute_update( + return; + } + // Start parsing value +- primary6y = json_payload.at("value").get(); ++ primary6y = json_payload.at("value").get(); + + // End parsing value + } +@@ -28931,7 +28931,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6_intensity_attribute_update + } + + +- int8_t primary6_intensity = {}; ++ uint8_t primary6_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -28944,7 +28944,7 @@ static void uic_mqtt_dotdot_on_color_control_primary6_intensity_attribute_update + return; + } + // Start parsing value +- primary6_intensity = json_payload.at("value").get(); ++ primary6_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29007,7 +29007,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointx_attribute_update( + } + + +- int16_t white_pointx = {}; ++ uint16_t white_pointx = {}; + + nlohmann::json json_payload; + try { +@@ -29020,7 +29020,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointx_attribute_update( + return; + } + // Start parsing value +- white_pointx = json_payload.at("value").get(); ++ white_pointx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29083,7 +29083,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointy_attribute_update( + } + + +- int16_t white_pointy = {}; ++ uint16_t white_pointy = {}; + + nlohmann::json json_payload; + try { +@@ -29096,7 +29096,7 @@ static void uic_mqtt_dotdot_on_color_control_white_pointy_attribute_update( + return; + } + // Start parsing value +- white_pointy = json_payload.at("value").get(); ++ white_pointy = json_payload.at("value").get(); + + // End parsing value + } +@@ -29159,7 +29159,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointrx_attribute_update( + } + + +- int16_t color_pointrx = {}; ++ uint16_t color_pointrx = {}; + + nlohmann::json json_payload; + try { +@@ -29172,7 +29172,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointrx_attribute_update( + return; + } + // Start parsing value +- color_pointrx = json_payload.at("value").get(); ++ color_pointrx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29235,7 +29235,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointry_attribute_update( + } + + +- int16_t color_pointry = {}; ++ uint16_t color_pointry = {}; + + nlohmann::json json_payload; + try { +@@ -29248,7 +29248,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointry_attribute_update( + return; + } + // Start parsing value +- color_pointry = json_payload.at("value").get(); ++ color_pointry = json_payload.at("value").get(); + + // End parsing value + } +@@ -29311,7 +29311,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointr_intensity_attribute_up + } + + +- int8_t color_pointr_intensity = {}; ++ uint8_t color_pointr_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29324,7 +29324,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointr_intensity_attribute_up + return; + } + // Start parsing value +- color_pointr_intensity = json_payload.at("value").get(); ++ color_pointr_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29387,7 +29387,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgx_attribute_update( + } + + +- int16_t color_pointgx = {}; ++ uint16_t color_pointgx = {}; + + nlohmann::json json_payload; + try { +@@ -29400,7 +29400,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgx_attribute_update( + return; + } + // Start parsing value +- color_pointgx = json_payload.at("value").get(); ++ color_pointgx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29463,7 +29463,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgy_attribute_update( + } + + +- int16_t color_pointgy = {}; ++ uint16_t color_pointgy = {}; + + nlohmann::json json_payload; + try { +@@ -29476,7 +29476,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointgy_attribute_update( + return; + } + // Start parsing value +- color_pointgy = json_payload.at("value").get(); ++ color_pointgy = json_payload.at("value").get(); + + // End parsing value + } +@@ -29539,7 +29539,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointg_intensity_attribute_up + } + + +- int8_t color_pointg_intensity = {}; ++ uint8_t color_pointg_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29552,7 +29552,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointg_intensity_attribute_up + return; + } + // Start parsing value +- color_pointg_intensity = json_payload.at("value").get(); ++ color_pointg_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29615,7 +29615,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointbx_attribute_update( + } + + +- int16_t color_pointbx = {}; ++ uint16_t color_pointbx = {}; + + nlohmann::json json_payload; + try { +@@ -29628,7 +29628,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointbx_attribute_update( + return; + } + // Start parsing value +- color_pointbx = json_payload.at("value").get(); ++ color_pointbx = json_payload.at("value").get(); + + // End parsing value + } +@@ -29691,7 +29691,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointby_attribute_update( + } + + +- int16_t color_pointby = {}; ++ uint16_t color_pointby = {}; + + nlohmann::json json_payload; + try { +@@ -29704,7 +29704,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointby_attribute_update( + return; + } + // Start parsing value +- color_pointby = json_payload.at("value").get(); ++ color_pointby = json_payload.at("value").get(); + + // End parsing value + } +@@ -29767,7 +29767,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointb_intensity_attribute_up + } + + +- int8_t color_pointb_intensity = {}; ++ uint8_t color_pointb_intensity = {}; + + nlohmann::json json_payload; + try { +@@ -29780,7 +29780,7 @@ static void uic_mqtt_dotdot_on_color_control_color_pointb_intensity_attribute_up + return; + } + // Start parsing value +- color_pointb_intensity = json_payload.at("value").get(); ++ color_pointb_intensity = json_payload.at("value").get(); + + // End parsing value + } +@@ -29843,7 +29843,7 @@ static void uic_mqtt_dotdot_on_color_control_enhanced_current_hue_attribute_upda + } + + +- int16_t enhanced_current_hue = {}; ++ uint16_t enhanced_current_hue = {}; + + nlohmann::json json_payload; + try { +@@ -29856,7 +29856,7 @@ static void uic_mqtt_dotdot_on_color_control_enhanced_current_hue_attribute_upda + return; + } + // Start parsing value +- enhanced_current_hue = json_payload.at("value").get(); ++ enhanced_current_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30003,7 +30003,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_active_attribute_update( + } + + +- int8_t color_loop_active = {}; ++ uint8_t color_loop_active = {}; + + nlohmann::json json_payload; + try { +@@ -30016,7 +30016,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_active_attribute_update( + return; + } + // Start parsing value +- color_loop_active = json_payload.at("value").get(); ++ color_loop_active = json_payload.at("value").get(); + + // End parsing value + } +@@ -30079,7 +30079,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_direction_attribute_upda + } + + +- int8_t color_loop_direction = {}; ++ uint8_t color_loop_direction = {}; + + nlohmann::json json_payload; + try { +@@ -30092,7 +30092,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_direction_attribute_upda + return; + } + // Start parsing value +- color_loop_direction = json_payload.at("value").get(); ++ color_loop_direction = json_payload.at("value").get(); + + // End parsing value + } +@@ -30155,7 +30155,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_time_attribute_update( + } + + +- int16_t color_loop_time = {}; ++ uint16_t color_loop_time = {}; + + nlohmann::json json_payload; + try { +@@ -30168,7 +30168,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_time_attribute_update( + return; + } + // Start parsing value +- color_loop_time = json_payload.at("value").get(); ++ color_loop_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -30231,7 +30231,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_start_enhanced_hue_attri + } + + +- int16_t color_loop_start_enhanced_hue = {}; ++ uint16_t color_loop_start_enhanced_hue = {}; + + nlohmann::json json_payload; + try { +@@ -30244,7 +30244,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_start_enhanced_hue_attri + return; + } + // Start parsing value +- color_loop_start_enhanced_hue = json_payload.at("value").get(); ++ color_loop_start_enhanced_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30307,7 +30307,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_stored_enhanced_hue_attr + } + + +- int16_t color_loop_stored_enhanced_hue = {}; ++ uint16_t color_loop_stored_enhanced_hue = {}; + + nlohmann::json json_payload; + try { +@@ -30320,7 +30320,7 @@ static void uic_mqtt_dotdot_on_color_control_color_loop_stored_enhanced_hue_attr + return; + } + // Start parsing value +- color_loop_stored_enhanced_hue = json_payload.at("value").get(); ++ color_loop_stored_enhanced_hue = json_payload.at("value").get(); + + // End parsing value + } +@@ -30459,7 +30459,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_min_mireds_attr + } + + +- int16_t color_temp_physical_min_mireds = {}; ++ uint16_t color_temp_physical_min_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30472,7 +30472,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_min_mireds_attr + return; + } + // Start parsing value +- color_temp_physical_min_mireds = json_payload.at("value").get(); ++ color_temp_physical_min_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30535,7 +30535,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_max_mireds_attr + } + + +- int16_t color_temp_physical_max_mireds = {}; ++ uint16_t color_temp_physical_max_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30548,7 +30548,7 @@ static void uic_mqtt_dotdot_on_color_control_color_temp_physical_max_mireds_attr + return; + } + // Start parsing value +- color_temp_physical_max_mireds = json_payload.at("value").get(); ++ color_temp_physical_max_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30611,7 +30611,7 @@ static void uic_mqtt_dotdot_on_color_control_couple_color_temp_to_level_min_mire + } + + +- int16_t couple_color_temp_to_level_min_mireds = {}; ++ uint16_t couple_color_temp_to_level_min_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30624,7 +30624,7 @@ static void uic_mqtt_dotdot_on_color_control_couple_color_temp_to_level_min_mire + return; + } + // Start parsing value +- couple_color_temp_to_level_min_mireds = json_payload.at("value").get(); ++ couple_color_temp_to_level_min_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -30687,7 +30687,7 @@ static void uic_mqtt_dotdot_on_color_control_start_up_color_temperature_mireds_a + } + + +- int16_t start_up_color_temperature_mireds = {}; ++ uint16_t start_up_color_temperature_mireds = {}; + + nlohmann::json json_payload; + try { +@@ -30700,7 +30700,7 @@ static void uic_mqtt_dotdot_on_color_control_start_up_color_temperature_mireds_a + return; + } + // Start parsing value +- start_up_color_temperature_mireds = json_payload.at("value").get(); ++ start_up_color_temperature_mireds = json_payload.at("value").get(); + + // End parsing value + } +@@ -31222,7 +31222,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_min_level_attribut + } + + +- int8_t physical_min_level = {}; ++ uint8_t physical_min_level = {}; + + nlohmann::json json_payload; + try { +@@ -31235,7 +31235,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_min_level_attribut + return; + } + // Start parsing value +- physical_min_level = json_payload.at("value").get(); ++ physical_min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31298,7 +31298,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_max_level_attribut + } + + +- int8_t physical_max_level = {}; ++ uint8_t physical_max_level = {}; + + nlohmann::json json_payload; + try { +@@ -31311,7 +31311,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_physical_max_level_attribut + return; + } + // Start parsing value +- physical_max_level = json_payload.at("value").get(); ++ physical_max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31450,7 +31450,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_min_level_attribute_update( + } + + +- int8_t min_level = {}; ++ uint8_t min_level = {}; + + nlohmann::json json_payload; + try { +@@ -31463,7 +31463,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_min_level_attribute_update( + return; + } + // Start parsing value +- min_level = json_payload.at("value").get(); ++ min_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31526,7 +31526,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_max_level_attribute_update( + } + + +- int8_t max_level = {}; ++ uint8_t max_level = {}; + + nlohmann::json json_payload; + try { +@@ -31539,7 +31539,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_max_level_attribute_update( + return; + } + // Start parsing value +- max_level = json_payload.at("value").get(); ++ max_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31602,7 +31602,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_level_attribute_up + } + + +- int8_t power_on_level = {}; ++ uint8_t power_on_level = {}; + + nlohmann::json json_payload; + try { +@@ -31615,7 +31615,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_level_attribute_up + return; + } + // Start parsing value +- power_on_level = json_payload.at("value").get(); ++ power_on_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -31678,7 +31678,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_fade_time_attribut + } + + +- int16_t power_on_fade_time = {}; ++ uint16_t power_on_fade_time = {}; + + nlohmann::json json_payload; + try { +@@ -31691,7 +31691,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_power_on_fade_time_attribut + return; + } + // Start parsing value +- power_on_fade_time = json_payload.at("value").get(); ++ power_on_fade_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -31754,7 +31754,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_intrinsic_ballast_factor_at + } + + +- int8_t intrinsic_ballast_factor = {}; ++ uint8_t intrinsic_ballast_factor = {}; + + nlohmann::json json_payload; + try { +@@ -31767,7 +31767,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_intrinsic_ballast_factor_at + return; + } + // Start parsing value +- intrinsic_ballast_factor = json_payload.at("value").get(); ++ intrinsic_ballast_factor = json_payload.at("value").get(); + + // End parsing value + } +@@ -31830,7 +31830,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_ballast_factor_adjustment_a + } + + +- int8_t ballast_factor_adjustment = {}; ++ uint8_t ballast_factor_adjustment = {}; + + nlohmann::json json_payload; + try { +@@ -31843,7 +31843,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_ballast_factor_adjustment_a + return; + } + // Start parsing value +- ballast_factor_adjustment = json_payload.at("value").get(); ++ ballast_factor_adjustment = json_payload.at("value").get(); + + // End parsing value + } +@@ -31906,7 +31906,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_quantity_attribute_upd + } + + +- int8_t lamp_quantity = {}; ++ uint8_t lamp_quantity = {}; + + nlohmann::json json_payload; + try { +@@ -31919,7 +31919,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_quantity_attribute_upd + return; + } + // Start parsing value +- lamp_quantity = json_payload.at("value").get(); ++ lamp_quantity = json_payload.at("value").get(); + + // End parsing value + } +@@ -32134,7 +32134,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_rated_hours_attribute_ + } + + +- int32_t lamp_rated_hours = {}; ++ uint32_t lamp_rated_hours = {}; + + nlohmann::json json_payload; + try { +@@ -32147,7 +32147,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_rated_hours_attribute_ + return; + } + // Start parsing value +- lamp_rated_hours = json_payload.at("value").get(); ++ lamp_rated_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -32210,7 +32210,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_attribute_u + } + + +- int32_t lamp_burn_hours = {}; ++ uint32_t lamp_burn_hours = {}; + + nlohmann::json json_payload; + try { +@@ -32223,7 +32223,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_attribute_u + return; + } + // Start parsing value +- lamp_burn_hours = json_payload.at("value").get(); ++ lamp_burn_hours = json_payload.at("value").get(); + + // End parsing value + } +@@ -32362,7 +32362,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_trip_point_ + } + + +- int32_t lamp_burn_hours_trip_point = {}; ++ uint32_t lamp_burn_hours_trip_point = {}; + + nlohmann::json json_payload; + try { +@@ -32375,7 +32375,7 @@ static void uic_mqtt_dotdot_on_ballast_configuration_lamp_burn_hours_trip_point_ + return; + } + // Start parsing value +- lamp_burn_hours_trip_point = json_payload.at("value").get(); ++ lamp_burn_hours_trip_point = json_payload.at("value").get(); + + // End parsing value + } +@@ -32598,7 +32598,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_measured_value_attribute_ + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32611,7 +32611,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_measured_value_attribute_ + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32674,7 +32674,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_min_measured_value_attrib + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32687,7 +32687,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_min_measured_value_attrib + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32750,7 +32750,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_max_measured_value_attrib + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -32763,7 +32763,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_max_measured_value_attrib + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -32826,7 +32826,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_tolerance_attribute_updat + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -32839,7 +32839,7 @@ static void uic_mqtt_dotdot_on_illuminance_measurement_tolerance_attribute_updat + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -33224,7 +33224,7 @@ static void uic_mqtt_dotdot_on_illuminance_level_sensing_illuminance_target_leve + } + + +- int16_t illuminance_target_level = {}; ++ uint16_t illuminance_target_level = {}; + + nlohmann::json json_payload; + try { +@@ -33237,7 +33237,7 @@ static void uic_mqtt_dotdot_on_illuminance_level_sensing_illuminance_target_leve + return; + } + // Start parsing value +- illuminance_target_level = json_payload.at("value").get(); ++ illuminance_target_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -33583,7 +33583,7 @@ static void uic_mqtt_dotdot_on_temperature_measurement_tolerance_attribute_updat + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -33596,7 +33596,7 @@ static void uic_mqtt_dotdot_on_temperature_measurement_tolerance_attribute_updat + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -33955,7 +33955,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_tolerance_attribute_update( + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -33968,7 +33968,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -34259,7 +34259,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_scaled_tolerance_attribute_u + } + + +- int16_t scaled_tolerance = {}; ++ uint16_t scaled_tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -34272,7 +34272,7 @@ static void uic_mqtt_dotdot_on_pressure_measurement_scaled_tolerance_attribute_u + return; + } + // Start parsing value +- scaled_tolerance = json_payload.at("value").get(); ++ scaled_tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -34514,7 +34514,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update( + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34527,7 +34527,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34590,7 +34590,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_min_measured_value_attribute_upd + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34603,7 +34603,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_min_measured_value_attribute_upd + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34666,7 +34666,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_upd + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34679,7 +34679,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_max_measured_value_attribute_upd + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34742,7 +34742,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update( + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -34755,7 +34755,7 @@ static void uic_mqtt_dotdot_on_flow_measurement_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -34881,7 +34881,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_measured_value_attribute_upda + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34894,7 +34894,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_measured_value_attribute_upda + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -34957,7 +34957,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_min_measured_value_attribute_ + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -34970,7 +34970,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_min_measured_value_attribute_ + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -35033,7 +35033,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_max_measured_value_attribute_ + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -35046,7 +35046,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_max_measured_value_attribute_ + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -35109,7 +35109,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_tolerance_attribute_update( + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -35122,7 +35122,7 @@ static void uic_mqtt_dotdot_on_relativity_humidity_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -35492,7 +35492,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_occupied_to_unoccupied_dela + } + + +- int16_t pir_occupied_to_unoccupied_delay = {}; ++ uint16_t pir_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35505,7 +35505,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_occupied_to_unoccupied_dela + return; + } + // Start parsing value +- pir_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ pir_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35568,7 +35568,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_dela + } + + +- int16_t pir_unoccupied_to_occupied_delay = {}; ++ uint16_t pir_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35581,7 +35581,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_dela + return; + } + // Start parsing value +- pir_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ pir_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35644,7 +35644,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_thre + } + + +- int8_t pir_unoccupied_to_occupied_threshold = {}; ++ uint8_t pir_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -35657,7 +35657,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_pir_unoccupied_to_occupied_thre + return; + } + // Start parsing value +- pir_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ pir_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -35720,7 +35720,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_occupied_to_unoccupi + } + + +- int16_t ultrasonic_occupied_to_unoccupied_delay = {}; ++ uint16_t ultrasonic_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35733,7 +35733,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_occupied_to_unoccupi + return; + } + // Start parsing value +- ultrasonic_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ ultrasonic_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35796,7 +35796,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + } + + +- int16_t ultrasonic_unoccupied_to_occupied_delay = {}; ++ uint16_t ultrasonic_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35809,7 +35809,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + return; + } + // Start parsing value +- ultrasonic_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ ultrasonic_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -35872,7 +35872,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + } + + +- int8_t ultrasonic_unoccupied_to_occupied_threshold = {}; ++ uint8_t ultrasonic_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -35885,7 +35885,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_ultrasonic_unoccupied_to_occupi + return; + } + // Start parsing value +- ultrasonic_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ ultrasonic_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -35948,7 +35948,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_occupied_to_un + } + + +- int16_t physical_contact_occupied_to_unoccupied_delay = {}; ++ uint16_t physical_contact_occupied_to_unoccupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -35961,7 +35961,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_occupied_to_un + return; + } + // Start parsing value +- physical_contact_occupied_to_unoccupied_delay = json_payload.at("value").get(); ++ physical_contact_occupied_to_unoccupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -36024,7 +36024,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + } + + +- int16_t physical_contact_unoccupied_to_occupied_delay = {}; ++ uint16_t physical_contact_unoccupied_to_occupied_delay = {}; + + nlohmann::json json_payload; + try { +@@ -36037,7 +36037,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + return; + } + // Start parsing value +- physical_contact_unoccupied_to_occupied_delay = json_payload.at("value").get(); ++ physical_contact_unoccupied_to_occupied_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -36100,7 +36100,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + } + + +- int8_t physical_contact_unoccupied_to_occupied_threshold = {}; ++ uint8_t physical_contact_unoccupied_to_occupied_threshold = {}; + + nlohmann::json json_payload; + try { +@@ -36113,7 +36113,7 @@ static void uic_mqtt_dotdot_on_occupancy_sensing_physical_contact_unoccupied_to_ + return; + } + // Start parsing value +- physical_contact_unoccupied_to_occupied_threshold = json_payload.at("value").get(); ++ physical_contact_unoccupied_to_occupied_threshold = json_payload.at("value").get(); + + // End parsing value + } +@@ -36303,7 +36303,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_measured_value_attribute_update( + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36316,7 +36316,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36379,7 +36379,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_min_measured_value_attribute_update + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36392,7 +36392,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_min_measured_value_attribute_update + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36455,7 +36455,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_max_measured_value_attribute_update + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36468,7 +36468,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_max_measured_value_attribute_update + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36531,7 +36531,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_tolerance_attribute_update( + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -36544,7 +36544,7 @@ static void uic_mqtt_dotdot_on_soil_moisture_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -36670,7 +36670,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_measured_value_attribute_update( + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36683,7 +36683,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_measured_value_attribute_update( + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36746,7 +36746,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_min_measured_value_attribute_updat + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36759,7 +36759,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_min_measured_value_attribute_updat + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36822,7 +36822,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_max_measured_value_attribute_updat + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -36835,7 +36835,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_max_measured_value_attribute_updat + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -36898,7 +36898,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_tolerance_attribute_update( + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -36911,7 +36911,7 @@ static void uic_mqtt_dotdot_on_ph_measurement_tolerance_attribute_update( + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -37037,7 +37037,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_measured_valu + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37050,7 +37050,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_measured_valu + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37113,7 +37113,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_min_measured_ + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37126,7 +37126,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_min_measured_ + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37189,7 +37189,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_max_measured_ + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37202,7 +37202,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_max_measured_ + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37265,7 +37265,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_tolerance_att + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -37278,7 +37278,7 @@ static void uic_mqtt_dotdot_on_electrical_conductivity_measurement_tolerance_att + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -37404,7 +37404,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_measured_value_attribute_u + } + + +- int16_t measured_value = {}; ++ uint16_t measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37417,7 +37417,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_measured_value_attribute_u + return; + } + // Start parsing value +- measured_value = json_payload.at("value").get(); ++ measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37480,7 +37480,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_min_measured_value_attribu + } + + +- int16_t min_measured_value = {}; ++ uint16_t min_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37493,7 +37493,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_min_measured_value_attribu + return; + } + // Start parsing value +- min_measured_value = json_payload.at("value").get(); ++ min_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37556,7 +37556,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_max_measured_value_attribu + } + + +- int16_t max_measured_value = {}; ++ uint16_t max_measured_value = {}; + + nlohmann::json json_payload; + try { +@@ -37569,7 +37569,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_max_measured_value_attribu + return; + } + // Start parsing value +- max_measured_value = json_payload.at("value").get(); ++ max_measured_value = json_payload.at("value").get(); + + // End parsing value + } +@@ -37632,7 +37632,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_tolerance_attribute_update + } + + +- int16_t tolerance = {}; ++ uint16_t tolerance = {}; + + nlohmann::json json_payload; + try { +@@ -37645,7 +37645,7 @@ static void uic_mqtt_dotdot_on_wind_speed_measurement_tolerance_attribute_update + return; + } + // Start parsing value +- tolerance = json_payload.at("value").get(); ++ tolerance = json_payload.at("value").get(); + + // End parsing value + } +@@ -39195,7 +39195,7 @@ static void uic_mqtt_dotdot_on_ias_zone_zoneid_attribute_update( + } + + +- int8_t zoneid = {}; ++ uint8_t zoneid = {}; + + nlohmann::json json_payload; + try { +@@ -39208,7 +39208,7 @@ static void uic_mqtt_dotdot_on_ias_zone_zoneid_attribute_update( + return; + } + // Start parsing value +- zoneid = json_payload.at("value").get(); ++ zoneid = json_payload.at("value").get(); + + // End parsing value + } +@@ -39271,7 +39271,7 @@ static void uic_mqtt_dotdot_on_ias_zone_number_of_zone_sensitivity_levels_suppor + } + + +- int8_t number_of_zone_sensitivity_levels_supported = {}; ++ uint8_t number_of_zone_sensitivity_levels_supported = {}; + + nlohmann::json json_payload; + try { +@@ -39284,7 +39284,7 @@ static void uic_mqtt_dotdot_on_ias_zone_number_of_zone_sensitivity_levels_suppor + return; + } + // Start parsing value +- number_of_zone_sensitivity_levels_supported = json_payload.at("value").get(); ++ number_of_zone_sensitivity_levels_supported = json_payload.at("value").get(); + + // End parsing value + } +@@ -39347,7 +39347,7 @@ static void uic_mqtt_dotdot_on_ias_zone_current_zone_sensitivity_level_attribute + } + + +- int8_t current_zone_sensitivity_level = {}; ++ uint8_t current_zone_sensitivity_level = {}; + + nlohmann::json json_payload; + try { +@@ -39360,7 +39360,7 @@ static void uic_mqtt_dotdot_on_ias_zone_current_zone_sensitivity_level_attribute + return; + } + // Start parsing value +- current_zone_sensitivity_level = json_payload.at("value").get(); ++ current_zone_sensitivity_level = json_payload.at("value").get(); + + // End parsing value + } +@@ -39507,7 +39507,7 @@ static void uic_mqtt_dotdot_on_iaswd_max_duration_attribute_update( + } + + +- int16_t max_duration = {}; ++ uint16_t max_duration = {}; + + nlohmann::json json_payload; + try { +@@ -39520,7 +39520,7 @@ static void uic_mqtt_dotdot_on_iaswd_max_duration_attribute_update( + return; + } + // Start parsing value +- max_duration = json_payload.at("value").get(); ++ max_duration = json_payload.at("value").get(); + + // End parsing value + } +@@ -39644,7 +39644,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_delivered_attribute_up + } + + +- int64_t current_summation_delivered = {}; ++ uint64_t current_summation_delivered = {}; + + nlohmann::json json_payload; + try { +@@ -39657,7 +39657,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_delivered_attribute_up + return; + } + // Start parsing value +- current_summation_delivered = json_payload.at("value").get(); ++ current_summation_delivered = json_payload.at("value").get(); + + // End parsing value + } +@@ -39720,7 +39720,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_received_attribute_upd + } + + +- int64_t current_summation_received = {}; ++ uint64_t current_summation_received = {}; + + nlohmann::json json_payload; + try { +@@ -39733,7 +39733,7 @@ static void uic_mqtt_dotdot_on_metering_current_summation_received_attribute_upd + return; + } + // Start parsing value +- current_summation_received = json_payload.at("value").get(); ++ current_summation_received = json_payload.at("value").get(); + + // End parsing value + } +@@ -39796,7 +39796,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_attribute_u + } + + +- int64_t current_max_demand_delivered = {}; ++ uint64_t current_max_demand_delivered = {}; + + nlohmann::json json_payload; + try { +@@ -39809,7 +39809,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_attribute_u + return; + } + // Start parsing value +- current_max_demand_delivered = json_payload.at("value").get(); ++ current_max_demand_delivered = json_payload.at("value").get(); + + // End parsing value + } +@@ -40024,7 +40024,7 @@ static void uic_mqtt_dotdot_on_metering_reading_snap_shot_time_attribute_update( + } + + +- uint8_t reading_snap_shot_time = {}; ++ uint32_t reading_snap_shot_time = {}; + + nlohmann::json json_payload; + try { +@@ -40037,7 +40037,7 @@ static void uic_mqtt_dotdot_on_metering_reading_snap_shot_time_attribute_update( + return; + } + // Start parsing value +- reading_snap_shot_time = json_payload.at("value").get(); ++ reading_snap_shot_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40100,7 +40100,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_time_attrib + } + + +- uint8_t current_max_demand_delivered_time = {}; ++ uint32_t current_max_demand_delivered_time = {}; + + nlohmann::json json_payload; + try { +@@ -40113,7 +40113,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_delivered_time_attrib + return; + } + // Start parsing value +- current_max_demand_delivered_time = json_payload.at("value").get(); ++ current_max_demand_delivered_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40176,7 +40176,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_received_time_attribu + } + + +- uint8_t current_max_demand_received_time = {}; ++ uint32_t current_max_demand_received_time = {}; + + nlohmann::json json_payload; + try { +@@ -40189,7 +40189,7 @@ static void uic_mqtt_dotdot_on_metering_current_max_demand_received_time_attribu + return; + } + // Start parsing value +- current_max_demand_received_time = json_payload.at("value").get(); ++ current_max_demand_received_time = json_payload.at("value").get(); + + // End parsing value + } +@@ -40252,7 +40252,7 @@ static void uic_mqtt_dotdot_on_metering_default_update_period_attribute_update( + } + + +- int8_t default_update_period = {}; ++ uint8_t default_update_period = {}; + + nlohmann::json json_payload; + try { +@@ -40265,7 +40265,7 @@ static void uic_mqtt_dotdot_on_metering_default_update_period_attribute_update( + return; + } + // Start parsing value +- default_update_period = json_payload.at("value").get(); ++ default_update_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -40412,7 +40412,7 @@ static void uic_mqtt_dotdot_on_metering_current_inlet_energy_carrier_summation_a + } + + +- int64_t current_inlet_energy_carrier_summation = {}; ++ uint64_t current_inlet_energy_carrier_summation = {}; + + nlohmann::json json_payload; + try { +@@ -40425,7 +40425,7 @@ static void uic_mqtt_dotdot_on_metering_current_inlet_energy_carrier_summation_a + return; + } + // Start parsing value +- current_inlet_energy_carrier_summation = json_payload.at("value").get(); ++ current_inlet_energy_carrier_summation = json_payload.at("value").get(); + + // End parsing value + } +@@ -40488,7 +40488,7 @@ static void uic_mqtt_dotdot_on_metering_current_outlet_energy_carrier_summation_ + } + + +- int64_t current_outlet_energy_carrier_summation = {}; ++ uint64_t current_outlet_energy_carrier_summation = {}; + + nlohmann::json json_payload; + try { +@@ -40501,7 +40501,7 @@ static void uic_mqtt_dotdot_on_metering_current_outlet_energy_carrier_summation_ + return; + } + // Start parsing value +- current_outlet_energy_carrier_summation = json_payload.at("value").get(); ++ current_outlet_energy_carrier_summation = json_payload.at("value").get(); + + // End parsing value + } +@@ -40800,7 +40800,7 @@ static void uic_mqtt_dotdot_on_metering_multiplier_attribute_update( + } + + +- int32_t multiplier = {}; ++ uint32_t multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -40813,7 +40813,7 @@ static void uic_mqtt_dotdot_on_metering_multiplier_attribute_update( + return; + } + // Start parsing value +- multiplier = json_payload.at("value").get(); ++ multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -40876,7 +40876,7 @@ static void uic_mqtt_dotdot_on_metering_divisor_attribute_update( + } + + +- int32_t divisor = {}; ++ uint32_t divisor = {}; + + nlohmann::json json_payload; + try { +@@ -40889,7 +40889,7 @@ static void uic_mqtt_dotdot_on_metering_divisor_attribute_update( + return; + } + // Start parsing value +- divisor = json_payload.at("value").get(); ++ divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -42782,7 +42782,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_multiplier_attr + } + + +- int16_t dc_voltage_multiplier = {}; ++ uint16_t dc_voltage_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -42795,7 +42795,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_multiplier_attr + return; + } + // Start parsing value +- dc_voltage_multiplier = json_payload.at("value").get(); ++ dc_voltage_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -42858,7 +42858,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_divisor_attribu + } + + +- int16_t dc_voltage_divisor = {}; ++ uint16_t dc_voltage_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -42871,7 +42871,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_voltage_divisor_attribu + return; + } + // Start parsing value +- dc_voltage_divisor = json_payload.at("value").get(); ++ dc_voltage_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -42934,7 +42934,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_multiplier_attr + } + + +- int16_t dc_current_multiplier = {}; ++ uint16_t dc_current_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -42947,7 +42947,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_multiplier_attr + return; + } + // Start parsing value +- dc_current_multiplier = json_payload.at("value").get(); ++ dc_current_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -43010,7 +43010,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_divisor_attribu + } + + +- int16_t dc_current_divisor = {}; ++ uint16_t dc_current_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -43023,7 +43023,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_current_divisor_attribu + return; + } + // Start parsing value +- dc_current_divisor = json_payload.at("value").get(); ++ dc_current_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -43086,7 +43086,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_multiplier_attrib + } + + +- int16_t dc_power_multiplier = {}; ++ uint16_t dc_power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -43099,7 +43099,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_multiplier_attrib + return; + } + // Start parsing value +- dc_power_multiplier = json_payload.at("value").get(); ++ dc_power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -43162,7 +43162,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_divisor_attribute + } + + +- int16_t dc_power_divisor = {}; ++ uint16_t dc_power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -43175,7 +43175,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_dc_power_divisor_attribute + return; + } + // Start parsing value +- dc_power_divisor = json_payload.at("value").get(); ++ dc_power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -43238,7 +43238,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_attribute_upd + } + + +- int16_t ac_frequency = {}; ++ uint16_t ac_frequency = {}; + + nlohmann::json json_payload; + try { +@@ -43251,7 +43251,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_attribute_upd + return; + } + // Start parsing value +- ac_frequency = json_payload.at("value").get(); ++ ac_frequency = json_payload.at("value").get(); + + // End parsing value + } +@@ -43314,7 +43314,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_min_attribute + } + + +- int16_t ac_frequency_min = {}; ++ uint16_t ac_frequency_min = {}; + + nlohmann::json json_payload; + try { +@@ -43327,7 +43327,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_min_attribute + return; + } + // Start parsing value +- ac_frequency_min = json_payload.at("value").get(); ++ ac_frequency_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -43390,7 +43390,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_max_attribute + } + + +- int16_t ac_frequency_max = {}; ++ uint16_t ac_frequency_max = {}; + + nlohmann::json json_payload; + try { +@@ -43403,7 +43403,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_max_attribute + return; + } + // Start parsing value +- ac_frequency_max = json_payload.at("value").get(); ++ ac_frequency_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -43466,7 +43466,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_neutral_current_attribute_ + } + + +- int16_t neutral_current = {}; ++ uint16_t neutral_current = {}; + + nlohmann::json json_payload; + try { +@@ -43479,7 +43479,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_neutral_current_attribute_ + return; + } + // Start parsing value +- neutral_current = json_payload.at("value").get(); ++ neutral_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -43694,7 +43694,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_total_apparent_power_attri + } + + +- int32_t total_apparent_power = {}; ++ uint32_t total_apparent_power = {}; + + nlohmann::json json_payload; + try { +@@ -43707,7 +43707,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_total_apparent_power_attri + return; + } + // Start parsing value +- total_apparent_power = json_payload.at("value").get(); ++ total_apparent_power = json_payload.at("value").get(); + + // End parsing value + } +@@ -44682,7 +44682,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_multiplier_at + } + + +- int16_t ac_frequency_multiplier = {}; ++ uint16_t ac_frequency_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -44695,7 +44695,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_multiplier_at + return; + } + // Start parsing value +- ac_frequency_multiplier = json_payload.at("value").get(); ++ ac_frequency_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -44758,7 +44758,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_divisor_attri + } + + +- int16_t ac_frequency_divisor = {}; ++ uint16_t ac_frequency_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -44771,7 +44771,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_frequency_divisor_attri + return; + } + // Start parsing value +- ac_frequency_divisor = json_payload.at("value").get(); ++ ac_frequency_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -44834,7 +44834,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_multiplier_attribute + } + + +- int32_t power_multiplier = {}; ++ uint32_t power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -44847,7 +44847,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_multiplier_attribute + return; + } + // Start parsing value +- power_multiplier = json_payload.at("value").get(); ++ power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -44910,7 +44910,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_divisor_attribute_up + } + + +- int32_t power_divisor = {}; ++ uint32_t power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -44923,7 +44923,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_power_divisor_attribute_up + return; + } + // Start parsing value +- power_divisor = json_payload.at("value").get(); ++ power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -45138,7 +45138,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_attribute_upd + } + + +- int16_t line_current = {}; ++ uint16_t line_current = {}; + + nlohmann::json json_payload; + try { +@@ -45151,7 +45151,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_attribute_upd + return; + } + // Start parsing value +- line_current = json_payload.at("value").get(); ++ line_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -45366,7 +45366,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_attribute_upda + } + + +- int16_t rms_voltage = {}; ++ uint16_t rms_voltage = {}; + + nlohmann::json json_payload; + try { +@@ -45379,7 +45379,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_attribute_upda + return; + } + // Start parsing value +- rms_voltage = json_payload.at("value").get(); ++ rms_voltage = json_payload.at("value").get(); + + // End parsing value + } +@@ -45442,7 +45442,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_attribute_ + } + + +- int16_t rms_voltage_min = {}; ++ uint16_t rms_voltage_min = {}; + + nlohmann::json json_payload; + try { +@@ -45455,7 +45455,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_attribute_ + return; + } + // Start parsing value +- rms_voltage_min = json_payload.at("value").get(); ++ rms_voltage_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -45518,7 +45518,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_attribute_ + } + + +- int16_t rms_voltage_max = {}; ++ uint16_t rms_voltage_max = {}; + + nlohmann::json json_payload; + try { +@@ -45531,7 +45531,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_attribute_ + return; + } + // Start parsing value +- rms_voltage_max = json_payload.at("value").get(); ++ rms_voltage_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -45594,7 +45594,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_attribute_upda + } + + +- int16_t rms_current = {}; ++ uint16_t rms_current = {}; + + nlohmann::json json_payload; + try { +@@ -45607,7 +45607,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_attribute_upda + return; + } + // Start parsing value +- rms_current = json_payload.at("value").get(); ++ rms_current = json_payload.at("value").get(); + + // End parsing value + } +@@ -45670,7 +45670,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_attribute_ + } + + +- int16_t rms_current_min = {}; ++ uint16_t rms_current_min = {}; + + nlohmann::json json_payload; + try { +@@ -45683,7 +45683,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_attribute_ + return; + } + // Start parsing value +- rms_current_min = json_payload.at("value").get(); ++ rms_current_min = json_payload.at("value").get(); + + // End parsing value + } +@@ -45746,7 +45746,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_attribute_ + } + + +- int16_t rms_current_max = {}; ++ uint16_t rms_current_max = {}; + + nlohmann::json json_payload; + try { +@@ -45759,7 +45759,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_attribute_ + return; + } + // Start parsing value +- rms_current_max = json_payload.at("value").get(); ++ rms_current_max = json_payload.at("value").get(); + + // End parsing value + } +@@ -46126,7 +46126,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_attribute_u + } + + +- int16_t apparent_power = {}; ++ uint16_t apparent_power = {}; + + nlohmann::json json_payload; + try { +@@ -46139,7 +46139,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_attribute_u + return; + } + // Start parsing value +- apparent_power = json_payload.at("value").get(); ++ apparent_power = json_payload.at("value").get(); + + // End parsing value + } +@@ -46278,7 +46278,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- int16_t average_rms_voltage_measurement_period = {}; ++ uint16_t average_rms_voltage_measurement_period = {}; + + nlohmann::json json_payload; + try { +@@ -46291,7 +46291,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46354,7 +46354,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- int16_t average_rms_over_voltage_counter = {}; ++ uint16_t average_rms_over_voltage_counter = {}; + + nlohmann::json json_payload; + try { +@@ -46367,7 +46367,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter = json_payload.at("value").get(); ++ average_rms_over_voltage_counter = json_payload.at("value").get(); + + // End parsing value + } +@@ -46430,7 +46430,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- int16_t average_rms_under_voltage_counter = {}; ++ uint16_t average_rms_under_voltage_counter = {}; + + nlohmann::json json_payload; + try { +@@ -46443,7 +46443,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter = json_payload.at("value").get(); ++ average_rms_under_voltage_counter = json_payload.at("value").get(); + + // End parsing value + } +@@ -46506,7 +46506,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- int16_t rms_extreme_over_voltage_period = {}; ++ uint16_t rms_extreme_over_voltage_period = {}; + + nlohmann::json json_payload; + try { +@@ -46519,7 +46519,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46582,7 +46582,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- int16_t rms_extreme_under_voltage_period = {}; ++ uint16_t rms_extreme_under_voltage_period = {}; + + nlohmann::json json_payload; + try { +@@ -46595,7 +46595,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46658,7 +46658,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_att + } + + +- int16_t rms_voltage_sag_period = {}; ++ uint16_t rms_voltage_sag_period = {}; + + nlohmann::json json_payload; + try { +@@ -46671,7 +46671,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_att + return; + } + // Start parsing value +- rms_voltage_sag_period = json_payload.at("value").get(); ++ rms_voltage_sag_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46734,7 +46734,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_a + } + + +- int16_t rms_voltage_swell_period = {}; ++ uint16_t rms_voltage_swell_period = {}; + + nlohmann::json json_payload; + try { +@@ -46747,7 +46747,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_a + return; + } + // Start parsing value +- rms_voltage_swell_period = json_payload.at("value").get(); ++ rms_voltage_swell_period = json_payload.at("value").get(); + + // End parsing value + } +@@ -46810,7 +46810,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_multiplier_attr + } + + +- int16_t ac_voltage_multiplier = {}; ++ uint16_t ac_voltage_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -46823,7 +46823,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_multiplier_attr + return; + } + // Start parsing value +- ac_voltage_multiplier = json_payload.at("value").get(); ++ ac_voltage_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -46886,7 +46886,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_divisor_attribu + } + + +- int16_t ac_voltage_divisor = {}; ++ uint16_t ac_voltage_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -46899,7 +46899,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_voltage_divisor_attribu + return; + } + // Start parsing value +- ac_voltage_divisor = json_payload.at("value").get(); ++ ac_voltage_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -46962,7 +46962,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_multiplier_attr + } + + +- int16_t ac_current_multiplier = {}; ++ uint16_t ac_current_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -46975,7 +46975,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_multiplier_attr + return; + } + // Start parsing value +- ac_current_multiplier = json_payload.at("value").get(); ++ ac_current_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -47038,7 +47038,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_divisor_attribu + } + + +- int16_t ac_current_divisor = {}; ++ uint16_t ac_current_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -47051,7 +47051,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_current_divisor_attribu + return; + } + // Start parsing value +- ac_current_divisor = json_payload.at("value").get(); ++ ac_current_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -47114,7 +47114,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_multiplier_attrib + } + + +- int16_t ac_power_multiplier = {}; ++ uint16_t ac_power_multiplier = {}; + + nlohmann::json json_payload; + try { +@@ -47127,7 +47127,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_multiplier_attrib + return; + } + // Start parsing value +- ac_power_multiplier = json_payload.at("value").get(); ++ ac_power_multiplier = json_payload.at("value").get(); + + // End parsing value + } +@@ -47190,7 +47190,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_divisor_attribute + } + + +- int16_t ac_power_divisor = {}; ++ uint16_t ac_power_divisor = {}; + + nlohmann::json json_payload; + try { +@@ -47203,7 +47203,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_ac_power_divisor_attribute + return; + } + // Start parsing value +- ac_power_divisor = json_payload.at("value").get(); ++ ac_power_divisor = json_payload.at("value").get(); + + // End parsing value + } +@@ -48330,7 +48330,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phb_attribute + } + + +- int16_t line_current_phb = {}; ++ uint16_t line_current_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48343,7 +48343,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phb_attribute + return; + } + // Start parsing value +- line_current_phb = json_payload.at("value").get(); ++ line_current_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48558,7 +48558,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phb_attribute_ + } + + +- int16_t rms_voltage_phb = {}; ++ uint16_t rms_voltage_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48571,7 +48571,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phb_attribute_ + return; + } + // Start parsing value +- rms_voltage_phb = json_payload.at("value").get(); ++ rms_voltage_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48634,7 +48634,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phb_attrib + } + + +- int16_t rms_voltage_min_phb = {}; ++ uint16_t rms_voltage_min_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48647,7 +48647,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phb_attrib + return; + } + // Start parsing value +- rms_voltage_min_phb = json_payload.at("value").get(); ++ rms_voltage_min_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48710,7 +48710,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phb_attrib + } + + +- int16_t rms_voltage_max_phb = {}; ++ uint16_t rms_voltage_max_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48723,7 +48723,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phb_attrib + return; + } + // Start parsing value +- rms_voltage_max_phb = json_payload.at("value").get(); ++ rms_voltage_max_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48786,7 +48786,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phb_attribute_ + } + + +- int16_t rms_current_phb = {}; ++ uint16_t rms_current_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48799,7 +48799,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phb_attribute_ + return; + } + // Start parsing value +- rms_current_phb = json_payload.at("value").get(); ++ rms_current_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48862,7 +48862,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phb_attrib + } + + +- int16_t rms_current_min_phb = {}; ++ uint16_t rms_current_min_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48875,7 +48875,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phb_attrib + return; + } + // Start parsing value +- rms_current_min_phb = json_payload.at("value").get(); ++ rms_current_min_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -48938,7 +48938,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phb_attrib + } + + +- int16_t rms_current_max_phb = {}; ++ uint16_t rms_current_max_phb = {}; + + nlohmann::json json_payload; + try { +@@ -48951,7 +48951,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phb_attrib + return; + } + // Start parsing value +- rms_current_max_phb = json_payload.at("value").get(); ++ rms_current_max_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49318,7 +49318,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phb_attribu + } + + +- int16_t apparent_power_phb = {}; ++ uint16_t apparent_power_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49331,7 +49331,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phb_attribu + return; + } + // Start parsing value +- apparent_power_phb = json_payload.at("value").get(); ++ apparent_power_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49470,7 +49470,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- int16_t average_rms_voltage_measurement_period_phb = {}; ++ uint16_t average_rms_voltage_measurement_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49483,7 +49483,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period_phb = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49546,7 +49546,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- int16_t average_rms_over_voltage_counter_phb = {}; ++ uint16_t average_rms_over_voltage_counter_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49559,7 +49559,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter_phb = json_payload.at("value").get(); ++ average_rms_over_voltage_counter_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49622,7 +49622,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- int16_t average_rms_under_voltage_counter_phb = {}; ++ uint16_t average_rms_under_voltage_counter_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49635,7 +49635,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter_phb = json_payload.at("value").get(); ++ average_rms_under_voltage_counter_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49698,7 +49698,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- int16_t rms_extreme_over_voltage_period_phb = {}; ++ uint16_t rms_extreme_over_voltage_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49711,7 +49711,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period_phb = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49774,7 +49774,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- int16_t rms_extreme_under_voltage_period_phb = {}; ++ uint16_t rms_extreme_under_voltage_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49787,7 +49787,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period_phb = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49850,7 +49850,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phb + } + + +- int16_t rms_voltage_sag_period_phb = {}; ++ uint16_t rms_voltage_sag_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49863,7 +49863,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phb + return; + } + // Start parsing value +- rms_voltage_sag_period_phb = json_payload.at("value").get(); ++ rms_voltage_sag_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -49926,7 +49926,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + } + + +- int16_t rms_voltage_swell_period_phb = {}; ++ uint16_t rms_voltage_swell_period_phb = {}; + + nlohmann::json json_payload; + try { +@@ -49939,7 +49939,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + return; + } + // Start parsing value +- rms_voltage_swell_period_phb = json_payload.at("value").get(); ++ rms_voltage_swell_period_phb = json_payload.at("value").get(); + + // End parsing value + } +@@ -50002,7 +50002,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phc_attribute + } + + +- int16_t line_current_phc = {}; ++ uint16_t line_current_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50015,7 +50015,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_line_current_phc_attribute + return; + } + // Start parsing value +- line_current_phc = json_payload.at("value").get(); ++ line_current_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50230,7 +50230,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phc_attribute_ + } + + +- int16_t rms_voltage_phc = {}; ++ uint16_t rms_voltage_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50243,7 +50243,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_phc_attribute_ + return; + } + // Start parsing value +- rms_voltage_phc = json_payload.at("value").get(); ++ rms_voltage_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50306,7 +50306,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phc_attrib + } + + +- int16_t rms_voltage_min_phc = {}; ++ uint16_t rms_voltage_min_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50319,7 +50319,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_min_phc_attrib + return; + } + // Start parsing value +- rms_voltage_min_phc = json_payload.at("value").get(); ++ rms_voltage_min_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50382,7 +50382,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phc_attrib + } + + +- int16_t rms_voltage_max_phc = {}; ++ uint16_t rms_voltage_max_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50395,7 +50395,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_max_phc_attrib + return; + } + // Start parsing value +- rms_voltage_max_phc = json_payload.at("value").get(); ++ rms_voltage_max_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50458,7 +50458,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phc_attribute_ + } + + +- int16_t rms_current_phc = {}; ++ uint16_t rms_current_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50471,7 +50471,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_phc_attribute_ + return; + } + // Start parsing value +- rms_current_phc = json_payload.at("value").get(); ++ rms_current_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50534,7 +50534,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phc_attrib + } + + +- int16_t rms_current_min_phc = {}; ++ uint16_t rms_current_min_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50547,7 +50547,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_min_phc_attrib + return; + } + // Start parsing value +- rms_current_min_phc = json_payload.at("value").get(); ++ rms_current_min_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50610,7 +50610,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phc_attrib + } + + +- int16_t rms_current_max_phc = {}; ++ uint16_t rms_current_max_phc = {}; + + nlohmann::json json_payload; + try { +@@ -50623,7 +50623,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_current_max_phc_attrib + return; + } + // Start parsing value +- rms_current_max_phc = json_payload.at("value").get(); ++ rms_current_max_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -50990,7 +50990,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phc_attribu + } + + +- int16_t apparent_power_phc = {}; ++ uint16_t apparent_power_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51003,7 +51003,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_apparent_power_phc_attribu + return; + } + // Start parsing value +- apparent_power_phc = json_payload.at("value").get(); ++ apparent_power_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51142,7 +51142,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + } + + +- int16_t average_rms_voltage_measurement_period_phc = {}; ++ uint16_t average_rms_voltage_measurement_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51155,7 +51155,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_voltage_measur + return; + } + // Start parsing value +- average_rms_voltage_measurement_period_phc = json_payload.at("value").get(); ++ average_rms_voltage_measurement_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51218,7 +51218,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + } + + +- int16_t average_rms_over_voltage_counter_phc = {}; ++ uint16_t average_rms_over_voltage_counter_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51231,7 +51231,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_over_voltage_c + return; + } + // Start parsing value +- average_rms_over_voltage_counter_phc = json_payload.at("value").get(); ++ average_rms_over_voltage_counter_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51294,7 +51294,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + } + + +- int16_t average_rms_under_voltage_counter_phc = {}; ++ uint16_t average_rms_under_voltage_counter_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51307,7 +51307,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_average_rms_under_voltage_ + return; + } + // Start parsing value +- average_rms_under_voltage_counter_phc = json_payload.at("value").get(); ++ average_rms_under_voltage_counter_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51370,7 +51370,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + } + + +- int16_t rms_extreme_over_voltage_period_phc = {}; ++ uint16_t rms_extreme_over_voltage_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51383,7 +51383,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_over_voltage_p + return; + } + // Start parsing value +- rms_extreme_over_voltage_period_phc = json_payload.at("value").get(); ++ rms_extreme_over_voltage_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51446,7 +51446,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + } + + +- int16_t rms_extreme_under_voltage_period_phc = {}; ++ uint16_t rms_extreme_under_voltage_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51459,7 +51459,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_extreme_under_voltage_ + return; + } + // Start parsing value +- rms_extreme_under_voltage_period_phc = json_payload.at("value").get(); ++ rms_extreme_under_voltage_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51522,7 +51522,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phc + } + + +- int16_t rms_voltage_sag_period_phc = {}; ++ uint16_t rms_voltage_sag_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51535,7 +51535,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_sag_period_phc + return; + } + // Start parsing value +- rms_voltage_sag_period_phc = json_payload.at("value").get(); ++ rms_voltage_sag_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -51598,7 +51598,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + } + + +- int16_t rms_voltage_swell_period_phc = {}; ++ uint16_t rms_voltage_swell_period_phc = {}; + + nlohmann::json json_payload; + try { +@@ -51611,7 +51611,7 @@ static void uic_mqtt_dotdot_on_electrical_measurement_rms_voltage_swell_period_p + return; + } + // Start parsing value +- rms_voltage_swell_period_phc = json_payload.at("value").get(); ++ rms_voltage_swell_period_phc = json_payload.at("value").get(); + + // End parsing value + } +@@ -52749,7 +52749,7 @@ static void uic_mqtt_dotdot_on_diagnostics_number_of_resets_attribute_update( + } + + +- int16_t number_of_resets = {}; ++ uint16_t number_of_resets = {}; + + nlohmann::json json_payload; + try { +@@ -52762,7 +52762,7 @@ static void uic_mqtt_dotdot_on_diagnostics_number_of_resets_attribute_update( + return; + } + // Start parsing value +- number_of_resets = json_payload.at("value").get(); ++ number_of_resets = json_payload.at("value").get(); + + // End parsing value + } +@@ -52825,7 +52825,7 @@ static void uic_mqtt_dotdot_on_diagnostics_persistent_memory_writes_attribute_up + } + + +- int16_t persistent_memory_writes = {}; ++ uint16_t persistent_memory_writes = {}; + + nlohmann::json json_payload; + try { +@@ -52838,7 +52838,7 @@ static void uic_mqtt_dotdot_on_diagnostics_persistent_memory_writes_attribute_up + return; + } + // Start parsing value +- persistent_memory_writes = json_payload.at("value").get(); ++ persistent_memory_writes = json_payload.at("value").get(); + + // End parsing value + } +@@ -52901,7 +52901,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_bcast_attribute_update( + } + + +- int32_t mac_rx_bcast = {}; ++ uint32_t mac_rx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -52914,7 +52914,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_bcast_attribute_update( + return; + } + // Start parsing value +- mac_rx_bcast = json_payload.at("value").get(); ++ mac_rx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -52977,7 +52977,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_bcast_attribute_update( + } + + +- int32_t mac_tx_bcast = {}; ++ uint32_t mac_tx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -52990,7 +52990,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_bcast_attribute_update( + return; + } + // Start parsing value +- mac_tx_bcast = json_payload.at("value").get(); ++ mac_tx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53053,7 +53053,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_ucast_attribute_update( + } + + +- int32_t mac_rx_ucast = {}; ++ uint32_t mac_rx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53066,7 +53066,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_rx_ucast_attribute_update( + return; + } + // Start parsing value +- mac_rx_ucast = json_payload.at("value").get(); ++ mac_rx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53129,7 +53129,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_attribute_update( + } + + +- int32_t mac_tx_ucast = {}; ++ uint32_t mac_tx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53142,7 +53142,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast = json_payload.at("value").get(); ++ mac_tx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53205,7 +53205,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_retry_attribute_update( + } + + +- int16_t mac_tx_ucast_retry = {}; ++ uint16_t mac_tx_ucast_retry = {}; + + nlohmann::json json_payload; + try { +@@ -53218,7 +53218,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_retry_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast_retry = json_payload.at("value").get(); ++ mac_tx_ucast_retry = json_payload.at("value").get(); + + // End parsing value + } +@@ -53281,7 +53281,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_fail_attribute_update( + } + + +- int16_t mac_tx_ucast_fail = {}; ++ uint16_t mac_tx_ucast_fail = {}; + + nlohmann::json json_payload; + try { +@@ -53294,7 +53294,7 @@ static void uic_mqtt_dotdot_on_diagnostics_mac_tx_ucast_fail_attribute_update( + return; + } + // Start parsing value +- mac_tx_ucast_fail = json_payload.at("value").get(); ++ mac_tx_ucast_fail = json_payload.at("value").get(); + + // End parsing value + } +@@ -53357,7 +53357,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_bcast_attribute_update( + } + + +- int16_t aps_rx_bcast = {}; ++ uint16_t aps_rx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -53370,7 +53370,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_bcast_attribute_update( + return; + } + // Start parsing value +- aps_rx_bcast = json_payload.at("value").get(); ++ aps_rx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53433,7 +53433,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_bcast_attribute_update( + } + + +- int16_t aps_tx_bcast = {}; ++ uint16_t aps_tx_bcast = {}; + + nlohmann::json json_payload; + try { +@@ -53446,7 +53446,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_bcast_attribute_update( + return; + } + // Start parsing value +- aps_tx_bcast = json_payload.at("value").get(); ++ aps_tx_bcast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53509,7 +53509,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_ucast_attribute_update( + } + + +- int16_t aps_rx_ucast = {}; ++ uint16_t aps_rx_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -53522,7 +53522,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_rx_ucast_attribute_update( + return; + } + // Start parsing value +- aps_rx_ucast = json_payload.at("value").get(); ++ aps_rx_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -53585,7 +53585,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_success_attribute_update + } + + +- int16_t aps_tx_ucast_success = {}; ++ uint16_t aps_tx_ucast_success = {}; + + nlohmann::json json_payload; + try { +@@ -53598,7 +53598,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_success_attribute_update + return; + } + // Start parsing value +- aps_tx_ucast_success = json_payload.at("value").get(); ++ aps_tx_ucast_success = json_payload.at("value").get(); + + // End parsing value + } +@@ -53661,7 +53661,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_retry_attribute_update( + } + + +- int16_t aps_tx_ucast_retry = {}; ++ uint16_t aps_tx_ucast_retry = {}; + + nlohmann::json json_payload; + try { +@@ -53674,7 +53674,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_retry_attribute_update( + return; + } + // Start parsing value +- aps_tx_ucast_retry = json_payload.at("value").get(); ++ aps_tx_ucast_retry = json_payload.at("value").get(); + + // End parsing value + } +@@ -53737,7 +53737,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_fail_attribute_update( + } + + +- int16_t aps_tx_ucast_fail = {}; ++ uint16_t aps_tx_ucast_fail = {}; + + nlohmann::json json_payload; + try { +@@ -53750,7 +53750,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_tx_ucast_fail_attribute_update( + return; + } + // Start parsing value +- aps_tx_ucast_fail = json_payload.at("value").get(); ++ aps_tx_ucast_fail = json_payload.at("value").get(); + + // End parsing value + } +@@ -53813,7 +53813,7 @@ static void uic_mqtt_dotdot_on_diagnostics_route_disc_initiated_attribute_update + } + + +- int16_t route_disc_initiated = {}; ++ uint16_t route_disc_initiated = {}; + + nlohmann::json json_payload; + try { +@@ -53826,7 +53826,7 @@ static void uic_mqtt_dotdot_on_diagnostics_route_disc_initiated_attribute_update + return; + } + // Start parsing value +- route_disc_initiated = json_payload.at("value").get(); ++ route_disc_initiated = json_payload.at("value").get(); + + // End parsing value + } +@@ -53889,7 +53889,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_added_attribute_update( + } + + +- int16_t neighbor_added = {}; ++ uint16_t neighbor_added = {}; + + nlohmann::json json_payload; + try { +@@ -53902,7 +53902,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_added_attribute_update( + return; + } + // Start parsing value +- neighbor_added = json_payload.at("value").get(); ++ neighbor_added = json_payload.at("value").get(); + + // End parsing value + } +@@ -53965,7 +53965,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_removed_attribute_update( + } + + +- int16_t neighbor_removed = {}; ++ uint16_t neighbor_removed = {}; + + nlohmann::json json_payload; + try { +@@ -53978,7 +53978,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_removed_attribute_update( + return; + } + // Start parsing value +- neighbor_removed = json_payload.at("value").get(); ++ neighbor_removed = json_payload.at("value").get(); + + // End parsing value + } +@@ -54041,7 +54041,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_stale_attribute_update( + } + + +- int16_t neighbor_stale = {}; ++ uint16_t neighbor_stale = {}; + + nlohmann::json json_payload; + try { +@@ -54054,7 +54054,7 @@ static void uic_mqtt_dotdot_on_diagnostics_neighbor_stale_attribute_update( + return; + } + // Start parsing value +- neighbor_stale = json_payload.at("value").get(); ++ neighbor_stale = json_payload.at("value").get(); + + // End parsing value + } +@@ -54117,7 +54117,7 @@ static void uic_mqtt_dotdot_on_diagnostics_join_indication_attribute_update( + } + + +- int16_t join_indication = {}; ++ uint16_t join_indication = {}; + + nlohmann::json json_payload; + try { +@@ -54130,7 +54130,7 @@ static void uic_mqtt_dotdot_on_diagnostics_join_indication_attribute_update( + return; + } + // Start parsing value +- join_indication = json_payload.at("value").get(); ++ join_indication = json_payload.at("value").get(); + + // End parsing value + } +@@ -54193,7 +54193,7 @@ static void uic_mqtt_dotdot_on_diagnostics_child_moved_attribute_update( + } + + +- int16_t child_moved = {}; ++ uint16_t child_moved = {}; + + nlohmann::json json_payload; + try { +@@ -54206,7 +54206,7 @@ static void uic_mqtt_dotdot_on_diagnostics_child_moved_attribute_update( + return; + } + // Start parsing value +- child_moved = json_payload.at("value").get(); ++ child_moved = json_payload.at("value").get(); + + // End parsing value + } +@@ -54269,7 +54269,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwkfc_failure_attribute_update( + } + + +- int16_t nwkfc_failure = {}; ++ uint16_t nwkfc_failure = {}; + + nlohmann::json json_payload; + try { +@@ -54282,7 +54282,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwkfc_failure_attribute_update( + return; + } + // Start parsing value +- nwkfc_failure = json_payload.at("value").get(); ++ nwkfc_failure = json_payload.at("value").get(); + + // End parsing value + } +@@ -54345,7 +54345,7 @@ static void uic_mqtt_dotdot_on_diagnostics_apsfc_failure_attribute_update( + } + + +- int16_t apsfc_failure = {}; ++ uint16_t apsfc_failure = {}; + + nlohmann::json json_payload; + try { +@@ -54358,7 +54358,7 @@ static void uic_mqtt_dotdot_on_diagnostics_apsfc_failure_attribute_update( + return; + } + // Start parsing value +- apsfc_failure = json_payload.at("value").get(); ++ apsfc_failure = json_payload.at("value").get(); + + // End parsing value + } +@@ -54421,7 +54421,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_unauthorized_key_attribute_update + } + + +- int16_t aps_unauthorized_key = {}; ++ uint16_t aps_unauthorized_key = {}; + + nlohmann::json json_payload; + try { +@@ -54434,7 +54434,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_unauthorized_key_attribute_update + return; + } + // Start parsing value +- aps_unauthorized_key = json_payload.at("value").get(); ++ aps_unauthorized_key = json_payload.at("value").get(); + + // End parsing value + } +@@ -54497,7 +54497,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwk_decrypt_failures_attribute_update + } + + +- int16_t nwk_decrypt_failures = {}; ++ uint16_t nwk_decrypt_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54510,7 +54510,7 @@ static void uic_mqtt_dotdot_on_diagnostics_nwk_decrypt_failures_attribute_update + return; + } + // Start parsing value +- nwk_decrypt_failures = json_payload.at("value").get(); ++ nwk_decrypt_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54573,7 +54573,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_decrypt_failures_attribute_update + } + + +- int16_t aps_decrypt_failures = {}; ++ uint16_t aps_decrypt_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54586,7 +54586,7 @@ static void uic_mqtt_dotdot_on_diagnostics_aps_decrypt_failures_attribute_update + return; + } + // Start parsing value +- aps_decrypt_failures = json_payload.at("value").get(); ++ aps_decrypt_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54649,7 +54649,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_buffer_allocate_failures_attri + } + + +- int16_t packet_buffer_allocate_failures = {}; ++ uint16_t packet_buffer_allocate_failures = {}; + + nlohmann::json json_payload; + try { +@@ -54662,7 +54662,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_buffer_allocate_failures_attri + return; + } + // Start parsing value +- packet_buffer_allocate_failures = json_payload.at("value").get(); ++ packet_buffer_allocate_failures = json_payload.at("value").get(); + + // End parsing value + } +@@ -54725,7 +54725,7 @@ static void uic_mqtt_dotdot_on_diagnostics_relayed_ucast_attribute_update( + } + + +- int16_t relayed_ucast = {}; ++ uint16_t relayed_ucast = {}; + + nlohmann::json json_payload; + try { +@@ -54738,7 +54738,7 @@ static void uic_mqtt_dotdot_on_diagnostics_relayed_ucast_attribute_update( + return; + } + // Start parsing value +- relayed_ucast = json_payload.at("value").get(); ++ relayed_ucast = json_payload.at("value").get(); + + // End parsing value + } +@@ -54801,7 +54801,7 @@ static void uic_mqtt_dotdot_on_diagnostics_phy_to_mac_queue_limit_reached_attrib + } + + +- int16_t phy_to_mac_queue_limit_reached = {}; ++ uint16_t phy_to_mac_queue_limit_reached = {}; + + nlohmann::json json_payload; + try { +@@ -54814,7 +54814,7 @@ static void uic_mqtt_dotdot_on_diagnostics_phy_to_mac_queue_limit_reached_attrib + return; + } + // Start parsing value +- phy_to_mac_queue_limit_reached = json_payload.at("value").get(); ++ phy_to_mac_queue_limit_reached = json_payload.at("value").get(); + + // End parsing value + } +@@ -54877,7 +54877,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_validate_drop_count_attribute_ + } + + +- int16_t packet_validate_drop_count = {}; ++ uint16_t packet_validate_drop_count = {}; + + nlohmann::json json_payload; + try { +@@ -54890,7 +54890,7 @@ static void uic_mqtt_dotdot_on_diagnostics_packet_validate_drop_count_attribute_ + return; + } + // Start parsing value +- packet_validate_drop_count = json_payload.at("value").get(); ++ packet_validate_drop_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -54953,7 +54953,7 @@ static void uic_mqtt_dotdot_on_diagnostics_average_mac_retry_per_aps_message_sen + } + + +- int16_t average_mac_retry_per_aps_message_sent = {}; ++ uint16_t average_mac_retry_per_aps_message_sent = {}; + + nlohmann::json json_payload; + try { +@@ -54966,7 +54966,7 @@ static void uic_mqtt_dotdot_on_diagnostics_average_mac_retry_per_aps_message_sen + return; + } + // Start parsing value +- average_mac_retry_per_aps_message_sent = json_payload.at("value").get(); ++ average_mac_retry_per_aps_message_sent = json_payload.at("value").get(); + + // End parsing value + } +@@ -55029,7 +55029,7 @@ static void uic_mqtt_dotdot_on_diagnostics_last_messagelqi_attribute_update( + } + + +- int8_t last_messagelqi = {}; ++ uint8_t last_messagelqi = {}; + + nlohmann::json json_payload; + try { +@@ -55042,7 +55042,7 @@ static void uic_mqtt_dotdot_on_diagnostics_last_messagelqi_attribute_update( + return; + } + // Start parsing value +- last_messagelqi = json_payload.at("value").get(); ++ last_messagelqi = json_payload.at("value").get(); + + // End parsing value + } +@@ -55666,7 +55666,7 @@ static void uic_mqtt_dotdot_on_state_endpoint_id_list_attribute_update( + } + + +- std::vector endpoint_id_list; ++ std::vector endpoint_id_list; + size_t endpoint_id_list_count = 0; + + nlohmann::json json_payload; +@@ -55682,7 +55682,7 @@ static void uic_mqtt_dotdot_on_state_endpoint_id_list_attribute_update( + // Start parsing value + auto &endpoint_id_list_json = json_payload.at("value"); + for (size_t i = 0; i < endpoint_id_list_json.size(); i++) { +- endpoint_id_list.push_back(endpoint_id_list_json.at(i).get()); ++ endpoint_id_list.push_back(endpoint_id_list_json.at(i).get()); + } + // Take our vector and pack it into the updated state + endpoint_id_list_count = endpoint_id_list.size(); +@@ -55917,7 +55917,7 @@ static void uic_mqtt_dotdot_on_state_maximum_command_delay_attribute_update( + } + + +- int32_t maximum_command_delay = {}; ++ uint32_t maximum_command_delay = {}; + + nlohmann::json json_payload; + try { +@@ -55930,7 +55930,7 @@ static void uic_mqtt_dotdot_on_state_maximum_command_delay_attribute_update( + return; + } + // Start parsing value +- maximum_command_delay = json_payload.at("value").get(); ++ maximum_command_delay = json_payload.at("value").get(); + + // End parsing value + } +@@ -56324,7 +56324,7 @@ static void uic_mqtt_dotdot_on_binding_binding_table_attribute_update( + BindingObject element = {}; + element.ClusterName = binding_table_json.at(i).at("ClusterName").get_ptr()->c_str(); + element.DestinationUnid = binding_table_json.at(i).at("DestinationUnid").get_ptr()->c_str(); +- element.DestinationEp = binding_table_json.at(i).at("DestinationEp").get(); ++ element.DestinationEp = binding_table_json.at(i).at("DestinationEp").get(); + binding_table.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -56470,7 +56470,7 @@ static void uic_mqtt_dotdot_on_system_metrics_reporting_interval_seconds_attribu + } + + +- int32_t reporting_interval_seconds = {}; ++ uint32_t reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -56483,7 +56483,7 @@ static void uic_mqtt_dotdot_on_system_metrics_reporting_interval_seconds_attribu + return; + } + // Start parsing value +- reporting_interval_seconds = json_payload.at("value").get(); ++ reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -57598,10 +57598,10 @@ static void uic_mqtt_dotdot_on_system_metrics_disks_counters_attribute_update( + for (size_t i = 0; i < disks_counters_json.size(); i++) { + DiskIOCounters element = {}; + element.UUID = disks_counters_json.at(i).at("UUID").get_ptr()->c_str(); +- element.ReadCount = disks_counters_json.at(i).at("ReadCount").get(); +- element.WriteCount = disks_counters_json.at(i).at("WriteCount").get(); +- element.ReadBytes = disks_counters_json.at(i).at("ReadBytes").get(); +- element.WriteBytes = disks_counters_json.at(i).at("WriteBytes").get(); ++ element.ReadCount = disks_counters_json.at(i).at("ReadCount").get(); ++ element.WriteCount = disks_counters_json.at(i).at("WriteCount").get(); ++ element.ReadBytes = disks_counters_json.at(i).at("ReadBytes").get(); ++ element.WriteBytes = disks_counters_json.at(i).at("WriteBytes").get(); + disks_counters.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -57687,14 +57687,14 @@ static void uic_mqtt_dotdot_on_system_metrics_network_interfaces_data_attribute_ + for (size_t i = 0; i < network_interfaces_data_json.size(); i++) { + NetworkInterfaceData element = {}; + element.InterfaceName = network_interfaces_data_json.at(i).at("InterfaceName").get_ptr()->c_str(); +- element.BytesSent = network_interfaces_data_json.at(i).at("BytesSent").get(); +- element.BytesReceived = network_interfaces_data_json.at(i).at("BytesReceived").get(); +- element.PacketsSent = network_interfaces_data_json.at(i).at("PacketsSent").get(); +- element.PacketsReceived = network_interfaces_data_json.at(i).at("PacketsReceived").get(); +- element.ErrorsIn = network_interfaces_data_json.at(i).at("ErrorsIn").get(); +- element.ErrorsOut = network_interfaces_data_json.at(i).at("ErrorsOut").get(); +- element.DropIn = network_interfaces_data_json.at(i).at("DropIn").get(); +- element.DropOut = network_interfaces_data_json.at(i).at("DropOut").get(); ++ element.BytesSent = network_interfaces_data_json.at(i).at("BytesSent").get(); ++ element.BytesReceived = network_interfaces_data_json.at(i).at("BytesReceived").get(); ++ element.PacketsSent = network_interfaces_data_json.at(i).at("PacketsSent").get(); ++ element.PacketsReceived = network_interfaces_data_json.at(i).at("PacketsReceived").get(); ++ element.ErrorsIn = network_interfaces_data_json.at(i).at("ErrorsIn").get(); ++ element.ErrorsOut = network_interfaces_data_json.at(i).at("ErrorsOut").get(); ++ element.DropIn = network_interfaces_data_json.at(i).at("DropIn").get(); ++ element.DropOut = network_interfaces_data_json.at(i).at("DropOut").get(); + network_interfaces_data.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -58000,7 +58000,7 @@ static void uic_mqtt_dotdot_on_system_metrics_uptime_minutes_attribute_update( + } + + +- int64_t uptime_minutes = {}; ++ uint64_t uptime_minutes = {}; + + nlohmann::json json_payload; + try { +@@ -58013,7 +58013,7 @@ static void uic_mqtt_dotdot_on_system_metrics_uptime_minutes_attribute_update( + return; + } + // Start parsing value +- uptime_minutes = json_payload.at("value").get(); ++ uptime_minutes = json_payload.at("value").get(); + + // End parsing value + } +@@ -58532,7 +58532,7 @@ static void uic_mqtt_dotdot_on_system_metrics_system_interrupts_attribute_update + } + + +- int64_t system_interrupts = {}; ++ uint64_t system_interrupts = {}; + + nlohmann::json json_payload; + try { +@@ -58545,7 +58545,7 @@ static void uic_mqtt_dotdot_on_system_metrics_system_interrupts_attribute_update + return; + } + // Start parsing value +- system_interrupts = json_payload.at("value").get(); ++ system_interrupts = json_payload.at("value").get(); + + // End parsing value + } +@@ -59185,7 +59185,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_uptime_minutes_attribute_u + } + + +- int64_t uptime_minutes = {}; ++ uint64_t uptime_minutes = {}; + + nlohmann::json json_payload; + try { +@@ -59198,7 +59198,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_uptime_minutes_attribute_u + return; + } + // Start parsing value +- uptime_minutes = json_payload.at("value").get(); ++ uptime_minutes = json_payload.at("value").get(); + + // End parsing value + } +@@ -59261,7 +59261,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_process_id_attribute_updat + } + + +- int64_t process_id = {}; ++ uint64_t process_id = {}; + + nlohmann::json json_payload; + try { +@@ -59274,7 +59274,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_process_id_attribute_updat + return; + } + // Start parsing value +- process_id = json_payload.at("value").get(); ++ process_id = json_payload.at("value").get(); + + // End parsing value + } +@@ -59649,7 +59649,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_statistics_reporting_ + } + + +- int32_t mqtt_statistics_reporting_interval_seconds = {}; ++ uint32_t mqtt_statistics_reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -59662,7 +59662,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_statistics_reporting_ + return; + } + // Start parsing value +- mqtt_statistics_reporting_interval_seconds = json_payload.at("value").get(); ++ mqtt_statistics_reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -59725,7 +59725,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_sent_attribu + } + + +- int64_t mqtt_messages_sent = {}; ++ uint64_t mqtt_messages_sent = {}; + + nlohmann::json json_payload; + try { +@@ -59738,7 +59738,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_sent_attribu + return; + } + // Start parsing value +- mqtt_messages_sent = json_payload.at("value").get(); ++ mqtt_messages_sent = json_payload.at("value").get(); + + // End parsing value + } +@@ -59801,7 +59801,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_received_att + } + + +- int64_t mqtt_messages_received = {}; ++ uint64_t mqtt_messages_received = {}; + + nlohmann::json json_payload; + try { +@@ -59814,7 +59814,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_messages_received_att + return; + } + // Start parsing value +- mqtt_messages_received = json_payload.at("value").get(); ++ mqtt_messages_received = json_payload.at("value").get(); + + // End parsing value + } +@@ -59877,7 +59877,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_subscription_count_at + } + + +- int64_t mqtt_subscription_count = {}; ++ uint64_t mqtt_subscription_count = {}; + + nlohmann::json json_payload; + try { +@@ -59890,7 +59890,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_mqtt_subscription_count_at + return; + } + // Start parsing value +- mqtt_subscription_count = json_payload.at("value").get(); ++ mqtt_subscription_count = json_payload.at("value").get(); + + // End parsing value + } +@@ -60181,7 +60181,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_application_statistics_rep + } + + +- int32_t application_statistics_reporting_interval_seconds = {}; ++ uint32_t application_statistics_reporting_interval_seconds = {}; + + nlohmann::json json_payload; + try { +@@ -60194,7 +60194,7 @@ static void uic_mqtt_dotdot_on_application_monitoring_application_statistics_rep + return; + } + // Start parsing value +- application_statistics_reporting_interval_seconds = json_payload.at("value").get(); ++ application_statistics_reporting_interval_seconds = json_payload.at("value").get(); + + // End parsing value + } +@@ -61063,7 +61063,7 @@ static void uic_mqtt_dotdot_on_configuration_parameters_configuration_parameters + auto &configuration_parameters_json = json_payload.at("value"); + for (size_t i = 0; i < configuration_parameters_json.size(); i++) { + ConfigurationParameter element = {}; +- element.ParameterId = configuration_parameters_json.at(i).at("ParameterId").get(); ++ element.ParameterId = configuration_parameters_json.at(i).at("ParameterId").get(); + element.Value = configuration_parameters_json.at(i).at("Value").get(); + element.Name = configuration_parameters_json.at(i).at("Name").get_ptr()->c_str(); + element.Info = configuration_parameters_json.at(i).at("Info").get_ptr()->c_str(); +@@ -61184,7 +61184,7 @@ static void uic_mqtt_dotdot_on_user_credential_supported_user_unique_identifiers + } + + +- int16_t supported_user_unique_identifiers = {}; ++ uint16_t supported_user_unique_identifiers = {}; + + nlohmann::json json_payload; + try { +@@ -61197,7 +61197,7 @@ static void uic_mqtt_dotdot_on_user_credential_supported_user_unique_identifiers + return; + } + // Start parsing value +- supported_user_unique_identifiers = json_payload.at("value").get(); ++ supported_user_unique_identifiers = json_payload.at("value").get(); + + // End parsing value + } +@@ -62017,7 +62017,7 @@ static void uic_mqtt_dotdot_on_descriptor_device_type_list_attribute_update( + for (size_t i = 0; i < device_type_list_json.size(); i++) { + DeviceTypeStruct element = {}; + element.DeviceType = device_type_list_json.at(i).at("DeviceType").get(); +- element.Revision = device_type_list_json.at(i).at("Revision").get(); ++ element.Revision = device_type_list_json.at(i).at("Revision").get(); + device_type_list.push_back(element); + } + // Take our vector and pack it into the updated state +@@ -63367,7 +63367,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_humidifier_setpoint_precis + } + + +- int8_t humidifier_setpoint_precision = {}; ++ uint8_t humidifier_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -63380,7 +63380,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_humidifier_setpoint_precis + return; + } + // Start parsing value +- humidifier_setpoint_precision = json_payload.at("value").get(); ++ humidifier_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +@@ -63755,7 +63755,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_dehumidifier_setpoint_prec + } + + +- int8_t dehumidifier_setpoint_precision = {}; ++ uint8_t dehumidifier_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -63768,7 +63768,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_dehumidifier_setpoint_prec + return; + } + // Start parsing value +- dehumidifier_setpoint_precision = json_payload.at("value").get(); ++ dehumidifier_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +@@ -64143,7 +64143,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_auto_setpoint_precision_at + } + + +- int8_t auto_setpoint_precision = {}; ++ uint8_t auto_setpoint_precision = {}; + + nlohmann::json json_payload; + try { +@@ -64156,7 +64156,7 @@ static void uic_mqtt_dotdot_on_unify_humidity_control_auto_setpoint_precision_at + return; + } + // Start parsing value +- auto_setpoint_precision = json_payload.at("value").get(); ++ auto_setpoint_precision = json_payload.at("value").get(); + + // End parsing value + } +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp +index 64fc94ecbf..9dcceb98fc 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.cpp +@@ -160,21 +160,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("MainsVoltageMinThreshold") != jsn.end()) { + +- new_state.mains_voltage_min_threshold = jsn.at("MainsVoltageMinThreshold").get(); ++ new_state.mains_voltage_min_threshold = jsn.at("MainsVoltageMinThreshold").get(); + + new_updated_state.mains_voltage_min_threshold = true; + } + + if (jsn.find("MainsVoltageMaxThreshold") != jsn.end()) { + +- new_state.mains_voltage_max_threshold = jsn.at("MainsVoltageMaxThreshold").get(); ++ new_state.mains_voltage_max_threshold = jsn.at("MainsVoltageMaxThreshold").get(); + + new_updated_state.mains_voltage_max_threshold = true; + } + + if (jsn.find("MainsVoltageDwellTripPoint") != jsn.end()) { + +- new_state.mains_voltage_dwell_trip_point = jsn.at("MainsVoltageDwellTripPoint").get(); ++ new_state.mains_voltage_dwell_trip_point = jsn.at("MainsVoltageDwellTripPoint").get(); + + new_updated_state.mains_voltage_dwell_trip_point = true; + } +@@ -203,21 +203,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("BatteryAHrRating") != jsn.end()) { + +- new_state.batterya_hr_rating = jsn.at("BatteryAHrRating").get(); ++ new_state.batterya_hr_rating = jsn.at("BatteryAHrRating").get(); + + new_updated_state.batterya_hr_rating = true; + } + + if (jsn.find("BatteryQuantity") != jsn.end()) { + +- new_state.battery_quantity = jsn.at("BatteryQuantity").get(); ++ new_state.battery_quantity = jsn.at("BatteryQuantity").get(); + + new_updated_state.battery_quantity = true; + } + + if (jsn.find("BatteryRatedVoltage") != jsn.end()) { + +- new_state.battery_rated_voltage = jsn.at("BatteryRatedVoltage").get(); ++ new_state.battery_rated_voltage = jsn.at("BatteryRatedVoltage").get(); + + new_updated_state.battery_rated_voltage = true; + } +@@ -231,56 +231,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("BatteryVoltageMinThreshold") != jsn.end()) { + +- new_state.battery_voltage_min_threshold = jsn.at("BatteryVoltageMinThreshold").get(); ++ new_state.battery_voltage_min_threshold = jsn.at("BatteryVoltageMinThreshold").get(); + + new_updated_state.battery_voltage_min_threshold = true; + } + + if (jsn.find("BatteryVoltageThreshold1") != jsn.end()) { + +- new_state.battery_voltage_threshold1 = jsn.at("BatteryVoltageThreshold1").get(); ++ new_state.battery_voltage_threshold1 = jsn.at("BatteryVoltageThreshold1").get(); + + new_updated_state.battery_voltage_threshold1 = true; + } + + if (jsn.find("BatteryVoltageThreshold2") != jsn.end()) { + +- new_state.battery_voltage_threshold2 = jsn.at("BatteryVoltageThreshold2").get(); ++ new_state.battery_voltage_threshold2 = jsn.at("BatteryVoltageThreshold2").get(); + + new_updated_state.battery_voltage_threshold2 = true; + } + + if (jsn.find("BatteryVoltageThreshold3") != jsn.end()) { + +- new_state.battery_voltage_threshold3 = jsn.at("BatteryVoltageThreshold3").get(); ++ new_state.battery_voltage_threshold3 = jsn.at("BatteryVoltageThreshold3").get(); + + new_updated_state.battery_voltage_threshold3 = true; + } + + if (jsn.find("BatteryPercentageMinThreshold") != jsn.end()) { + +- new_state.battery_percentage_min_threshold = jsn.at("BatteryPercentageMinThreshold").get(); ++ new_state.battery_percentage_min_threshold = jsn.at("BatteryPercentageMinThreshold").get(); + + new_updated_state.battery_percentage_min_threshold = true; + } + + if (jsn.find("BatteryPercentageThreshold1") != jsn.end()) { + +- new_state.battery_percentage_threshold1 = jsn.at("BatteryPercentageThreshold1").get(); ++ new_state.battery_percentage_threshold1 = jsn.at("BatteryPercentageThreshold1").get(); + + new_updated_state.battery_percentage_threshold1 = true; + } + + if (jsn.find("BatteryPercentageThreshold2") != jsn.end()) { + +- new_state.battery_percentage_threshold2 = jsn.at("BatteryPercentageThreshold2").get(); ++ new_state.battery_percentage_threshold2 = jsn.at("BatteryPercentageThreshold2").get(); + + new_updated_state.battery_percentage_threshold2 = true; + } + + if (jsn.find("BatteryPercentageThreshold3") != jsn.end()) { + +- new_state.battery_percentage_threshold3 = jsn.at("BatteryPercentageThreshold3").get(); ++ new_state.battery_percentage_threshold3 = jsn.at("BatteryPercentageThreshold3").get(); + + new_updated_state.battery_percentage_threshold3 = true; + } +@@ -309,21 +309,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery2AHrRating") != jsn.end()) { + +- new_state.battery2a_hr_rating = jsn.at("Battery2AHrRating").get(); ++ new_state.battery2a_hr_rating = jsn.at("Battery2AHrRating").get(); + + new_updated_state.battery2a_hr_rating = true; + } + + if (jsn.find("Battery2Quantity") != jsn.end()) { + +- new_state.battery2_quantity = jsn.at("Battery2Quantity").get(); ++ new_state.battery2_quantity = jsn.at("Battery2Quantity").get(); + + new_updated_state.battery2_quantity = true; + } + + if (jsn.find("Battery2RatedVoltage") != jsn.end()) { + +- new_state.battery2_rated_voltage = jsn.at("Battery2RatedVoltage").get(); ++ new_state.battery2_rated_voltage = jsn.at("Battery2RatedVoltage").get(); + + new_updated_state.battery2_rated_voltage = true; + } +@@ -337,56 +337,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery2VoltageMinThreshold") != jsn.end()) { + +- new_state.battery2_voltage_min_threshold = jsn.at("Battery2VoltageMinThreshold").get(); ++ new_state.battery2_voltage_min_threshold = jsn.at("Battery2VoltageMinThreshold").get(); + + new_updated_state.battery2_voltage_min_threshold = true; + } + + if (jsn.find("Battery2VoltageThreshold1") != jsn.end()) { + +- new_state.battery2_voltage_threshold1 = jsn.at("Battery2VoltageThreshold1").get(); ++ new_state.battery2_voltage_threshold1 = jsn.at("Battery2VoltageThreshold1").get(); + + new_updated_state.battery2_voltage_threshold1 = true; + } + + if (jsn.find("Battery2VoltageThreshold2") != jsn.end()) { + +- new_state.battery2_voltage_threshold2 = jsn.at("Battery2VoltageThreshold2").get(); ++ new_state.battery2_voltage_threshold2 = jsn.at("Battery2VoltageThreshold2").get(); + + new_updated_state.battery2_voltage_threshold2 = true; + } + + if (jsn.find("Battery2VoltageThreshold3") != jsn.end()) { + +- new_state.battery2_voltage_threshold3 = jsn.at("Battery2VoltageThreshold3").get(); ++ new_state.battery2_voltage_threshold3 = jsn.at("Battery2VoltageThreshold3").get(); + + new_updated_state.battery2_voltage_threshold3 = true; + } + + if (jsn.find("Battery2PercentageMinThreshold") != jsn.end()) { + +- new_state.battery2_percentage_min_threshold = jsn.at("Battery2PercentageMinThreshold").get(); ++ new_state.battery2_percentage_min_threshold = jsn.at("Battery2PercentageMinThreshold").get(); + + new_updated_state.battery2_percentage_min_threshold = true; + } + + if (jsn.find("Battery2PercentageThreshold1") != jsn.end()) { + +- new_state.battery2_percentage_threshold1 = jsn.at("Battery2PercentageThreshold1").get(); ++ new_state.battery2_percentage_threshold1 = jsn.at("Battery2PercentageThreshold1").get(); + + new_updated_state.battery2_percentage_threshold1 = true; + } + + if (jsn.find("Battery2PercentageThreshold2") != jsn.end()) { + +- new_state.battery2_percentage_threshold2 = jsn.at("Battery2PercentageThreshold2").get(); ++ new_state.battery2_percentage_threshold2 = jsn.at("Battery2PercentageThreshold2").get(); + + new_updated_state.battery2_percentage_threshold2 = true; + } + + if (jsn.find("Battery2PercentageThreshold3") != jsn.end()) { + +- new_state.battery2_percentage_threshold3 = jsn.at("Battery2PercentageThreshold3").get(); ++ new_state.battery2_percentage_threshold3 = jsn.at("Battery2PercentageThreshold3").get(); + + new_updated_state.battery2_percentage_threshold3 = true; + } +@@ -415,21 +415,21 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery3AHrRating") != jsn.end()) { + +- new_state.battery3a_hr_rating = jsn.at("Battery3AHrRating").get(); ++ new_state.battery3a_hr_rating = jsn.at("Battery3AHrRating").get(); + + new_updated_state.battery3a_hr_rating = true; + } + + if (jsn.find("Battery3Quantity") != jsn.end()) { + +- new_state.battery3_quantity = jsn.at("Battery3Quantity").get(); ++ new_state.battery3_quantity = jsn.at("Battery3Quantity").get(); + + new_updated_state.battery3_quantity = true; + } + + if (jsn.find("Battery3RatedVoltage") != jsn.end()) { + +- new_state.battery3_rated_voltage = jsn.at("Battery3RatedVoltage").get(); ++ new_state.battery3_rated_voltage = jsn.at("Battery3RatedVoltage").get(); + + new_updated_state.battery3_rated_voltage = true; + } +@@ -443,56 +443,56 @@ void uic_mqtt_dotdot_parse_power_configuration_write_attributes( + + if (jsn.find("Battery3VoltageMinThreshold") != jsn.end()) { + +- new_state.battery3_voltage_min_threshold = jsn.at("Battery3VoltageMinThreshold").get(); ++ new_state.battery3_voltage_min_threshold = jsn.at("Battery3VoltageMinThreshold").get(); + + new_updated_state.battery3_voltage_min_threshold = true; + } + + if (jsn.find("Battery3VoltageThreshold1") != jsn.end()) { + +- new_state.battery3_voltage_threshold1 = jsn.at("Battery3VoltageThreshold1").get(); ++ new_state.battery3_voltage_threshold1 = jsn.at("Battery3VoltageThreshold1").get(); + + new_updated_state.battery3_voltage_threshold1 = true; + } + + if (jsn.find("Battery3VoltageThreshold2") != jsn.end()) { + +- new_state.battery3_voltage_threshold2 = jsn.at("Battery3VoltageThreshold2").get(); ++ new_state.battery3_voltage_threshold2 = jsn.at("Battery3VoltageThreshold2").get(); + + new_updated_state.battery3_voltage_threshold2 = true; + } + + if (jsn.find("Battery3VoltageThreshold3") != jsn.end()) { + +- new_state.battery3_voltage_threshold3 = jsn.at("Battery3VoltageThreshold3").get(); ++ new_state.battery3_voltage_threshold3 = jsn.at("Battery3VoltageThreshold3").get(); + + new_updated_state.battery3_voltage_threshold3 = true; + } + + if (jsn.find("Battery3PercentageMinThreshold") != jsn.end()) { + +- new_state.battery3_percentage_min_threshold = jsn.at("Battery3PercentageMinThreshold").get(); ++ new_state.battery3_percentage_min_threshold = jsn.at("Battery3PercentageMinThreshold").get(); + + new_updated_state.battery3_percentage_min_threshold = true; + } + + if (jsn.find("Battery3PercentageThreshold1") != jsn.end()) { + +- new_state.battery3_percentage_threshold1 = jsn.at("Battery3PercentageThreshold1").get(); ++ new_state.battery3_percentage_threshold1 = jsn.at("Battery3PercentageThreshold1").get(); + + new_updated_state.battery3_percentage_threshold1 = true; + } + + if (jsn.find("Battery3PercentageThreshold2") != jsn.end()) { + +- new_state.battery3_percentage_threshold2 = jsn.at("Battery3PercentageThreshold2").get(); ++ new_state.battery3_percentage_threshold2 = jsn.at("Battery3PercentageThreshold2").get(); + + new_updated_state.battery3_percentage_threshold2 = true; + } + + if (jsn.find("Battery3PercentageThreshold3") != jsn.end()) { + +- new_state.battery3_percentage_threshold3 = jsn.at("Battery3PercentageThreshold3").get(); ++ new_state.battery3_percentage_threshold3 = jsn.at("Battery3PercentageThreshold3").get(); + + new_updated_state.battery3_percentage_threshold3 = true; + } +@@ -536,14 +536,14 @@ void uic_mqtt_dotdot_parse_device_temperature_configuration_write_attributes( + + if (jsn.find("LowTempDwellTripPoint") != jsn.end()) { + +- new_state.low_temp_dwell_trip_point = jsn.at("LowTempDwellTripPoint").get(); ++ new_state.low_temp_dwell_trip_point = jsn.at("LowTempDwellTripPoint").get(); + + new_updated_state.low_temp_dwell_trip_point = true; + } + + if (jsn.find("HighTempDwellTripPoint") != jsn.end()) { + +- new_state.high_temp_dwell_trip_point = jsn.at("HighTempDwellTripPoint").get(); ++ new_state.high_temp_dwell_trip_point = jsn.at("HighTempDwellTripPoint").get(); + + new_updated_state.high_temp_dwell_trip_point = true; + } +@@ -577,7 +577,7 @@ std::string get_json_payload_for_identify_identify_command( + + void uic_mqtt_dotdot_parse_identify_identify( + nlohmann::json &jsn, +- int16_t &identify_time ++ uint16_t &identify_time + + ) { + +@@ -586,7 +586,7 @@ void uic_mqtt_dotdot_parse_identify_identify( + return; + } + +- identify_time = jsn.at("IdentifyTime").get< int16_t >(); ++ identify_time = jsn.at("IdentifyTime").get< uint16_t >(); + } + + +@@ -615,7 +615,7 @@ std::string get_json_payload_for_identify_identify_query_response_command( + + void uic_mqtt_dotdot_parse_identify_identify_query_response( + nlohmann::json &jsn, +- int16_t &timeout ++ uint16_t &timeout + + ) { + +@@ -624,7 +624,7 @@ void uic_mqtt_dotdot_parse_identify_identify_query_response( + return; + } + +- timeout = jsn.at("Timeout").get< int16_t >(); ++ timeout = jsn.at("Timeout").get< uint16_t >(); + } + + +@@ -743,7 +743,7 @@ void uic_mqtt_dotdot_parse_identify_write_attributes( + + if (jsn.find("IdentifyTime") != jsn.end()) { + +- new_state.identify_time = jsn.at("IdentifyTime").get(); ++ new_state.identify_time = jsn.at("IdentifyTime").get(); + + new_updated_state.identify_time = true; + } +@@ -781,7 +781,7 @@ std::string get_json_payload_for_groups_add_group_command( + + void uic_mqtt_dotdot_parse_groups_add_group( + nlohmann::json &jsn, +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -792,7 +792,7 @@ void uic_mqtt_dotdot_parse_groups_add_group( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -844,7 +844,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id ++ uint16_t &group_id + + ) { + +@@ -864,7 +864,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + } + + +@@ -893,7 +893,7 @@ std::string get_json_payload_for_groups_view_group_command( + + void uic_mqtt_dotdot_parse_groups_view_group( + nlohmann::json &jsn, +- int16_t &group_id ++ uint16_t &group_id + + ) { + +@@ -902,7 +902,7 @@ void uic_mqtt_dotdot_parse_groups_view_group( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + } + + +@@ -952,7 +952,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -974,7 +974,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -995,7 +995,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + nlohmann::json json_payload; + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["GroupList"] = std::vector< int16_t >( ++ json_payload["GroupList"] = std::vector< uint16_t >( + fields->group_list, + fields->group_list + fields->group_list_count); + +@@ -1011,7 +1011,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + + void uic_mqtt_dotdot_parse_groups_get_group_membership( + nlohmann::json &jsn, +- std::vector &group_list ++ std::vector &group_list + + ) { + +@@ -1020,7 +1020,7 @@ void uic_mqtt_dotdot_parse_groups_get_group_membership( + return; + } + +- group_list = jsn.at("GroupList").get< std::vector< int16_t >>(); ++ group_list = jsn.at("GroupList").get< std::vector< uint16_t >>(); + } + + +@@ -1039,7 +1039,7 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + json_payload["Capacity"] = nlohmann::json(fields->capacity); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["GroupList"] = std::vector< int16_t >( ++ json_payload["GroupList"] = std::vector< uint16_t >( + fields->group_list, + fields->group_list + fields->group_list_count); + +@@ -1055,9 +1055,9 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + + void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + nlohmann::json &jsn, +- int8_t &capacity, ++ uint8_t &capacity, + +- std::vector &group_list ++ std::vector &group_list + + ) { + +@@ -1066,13 +1066,13 @@ void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + return; + } + +- capacity = jsn.at("Capacity").get< int8_t >(); ++ capacity = jsn.at("Capacity").get< uint8_t >(); + if (jsn.at("GroupList").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- group_list = jsn.at("GroupList").get< std::vector< int16_t >>(); ++ group_list = jsn.at("GroupList").get< std::vector< uint16_t >>(); + } + + +@@ -1101,7 +1101,7 @@ std::string get_json_payload_for_groups_remove_group_command( + + void uic_mqtt_dotdot_parse_groups_remove_group( + nlohmann::json &jsn, +- int16_t &group_id ++ uint16_t &group_id + + ) { + +@@ -1110,7 +1110,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + } + + +@@ -1156,7 +1156,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id ++ uint16_t &group_id + + ) { + +@@ -1176,7 +1176,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + } + + +@@ -1228,7 +1228,7 @@ std::string get_json_payload_for_groups_add_group_if_identifying_command( + + void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + nlohmann::json &jsn, +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -1239,7 +1239,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + return; + } + +- group_id = jsn.at("GroupId").get< int16_t >(); ++ group_id = jsn.at("GroupId").get< uint16_t >(); + if (jsn.at("GroupName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1312,17 +1312,17 @@ std::string get_json_payload_for_scenes_add_scene_command( + + void uic_mqtt_dotdot_parse_scenes_add_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + + std::vector &extension_field_sets, + +- int8_t &transition_time100ms ++ uint8_t &transition_time100ms + + ) { + +@@ -1331,19 +1331,19 @@ void uic_mqtt_dotdot_parse_scenes_add_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1375,7 +1375,7 @@ void uic_mqtt_dotdot_parse_scenes_add_scene( + return; + } + +- transition_time100ms = jsn.at("TransitionTime100ms").get< int8_t >(); ++ transition_time100ms = jsn.at("TransitionTime100ms").get< uint8_t >(); + } + + +@@ -1425,9 +1425,9 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1447,13 +1447,13 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -1486,9 +1486,9 @@ std::string get_json_payload_for_scenes_view_scene_command( + + void uic_mqtt_dotdot_parse_scenes_view_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1497,13 +1497,13 @@ void uic_mqtt_dotdot_parse_scenes_view_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -1567,11 +1567,11 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -1595,19 +1595,19 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -1666,9 +1666,9 @@ std::string get_json_payload_for_scenes_remove_scene_command( + + void uic_mqtt_dotdot_parse_scenes_remove_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1677,13 +1677,13 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -1733,9 +1733,9 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1755,13 +1755,13 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -1790,7 +1790,7 @@ std::string get_json_payload_for_scenes_remove_all_scenes_command( + + void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + nlohmann::json &jsn, +- uint8_t * &groupid ++ uint16_t &groupid + + ) { + +@@ -1799,7 +1799,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + } + + +@@ -1845,7 +1845,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid ++ uint16_t &groupid + + ) { + +@@ -1865,7 +1865,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + } + + +@@ -1898,9 +1898,9 @@ std::string get_json_payload_for_scenes_store_scene_command( + + void uic_mqtt_dotdot_parse_scenes_store_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1909,13 +1909,13 @@ void uic_mqtt_dotdot_parse_scenes_store_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -1965,9 +1965,9 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -1987,13 +1987,13 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -2030,11 +2030,11 @@ std::string get_json_payload_for_scenes_recall_scene_command( + + void uic_mqtt_dotdot_parse_scenes_recall_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time ++ uint16_t &transition_time + + ) { + +@@ -2043,19 +2043,19 @@ void uic_mqtt_dotdot_parse_scenes_recall_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + } + + +@@ -2084,7 +2084,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_command( + + void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + nlohmann::json &jsn, +- uint8_t * &groupid ++ uint16_t &groupid + + ) { + +@@ -2093,7 +2093,7 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + } + + +@@ -2131,7 +2131,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_response_command( + json_payload["GroupID"] = nlohmann::json(fields->groupid); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["SceneList"] = std::vector< int8_t >( ++ json_payload["SceneList"] = std::vector< uint8_t >( + fields->scene_list, + fields->scene_list + fields->scene_list_count); + +@@ -2149,11 +2149,11 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + nlohmann::json &jsn, + zclStatus &status, + +- int8_t &capacity, ++ uint8_t &capacity, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- std::vector &scene_list ++ std::vector &scene_list + + ) { + +@@ -2173,19 +2173,19 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + return; + } + +- capacity = jsn.at("Capacity").get< int8_t >(); ++ capacity = jsn.at("Capacity").get< uint8_t >(); + if (jsn.at("GroupID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneList").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_list = jsn.at("SceneList").get< std::vector< int8_t >>(); ++ scene_list = jsn.at("SceneList").get< std::vector< uint8_t >>(); + } + + +@@ -2232,11 +2232,11 @@ std::string get_json_payload_for_scenes_enhanced_add_scene_command( + + void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -2249,19 +2249,19 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -2337,9 +2337,9 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -2359,13 +2359,13 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -2398,9 +2398,9 @@ std::string get_json_payload_for_scenes_enhanced_view_scene_command( + + void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ) { + +@@ -2409,13 +2409,13 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + } + + +@@ -2479,11 +2479,11 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -2507,19 +2507,19 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + return; + } + +- groupid = jsn.at("GroupID").get< uint8_t * >(); ++ groupid = jsn.at("GroupID").get< uint16_t >(); + if (jsn.at("SceneID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- sceneid = jsn.at("SceneID").get< int8_t >(); ++ sceneid = jsn.at("SceneID").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("SceneName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -2594,13 +2594,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + nlohmann::json &jsn, + uint8_t &mode, + +- uint8_t * &group_identifier_from, ++ uint16_t &group_identifier_from, + +- int8_t &scene_identifier_from, ++ uint8_t &scene_identifier_from, + +- uint8_t * &group_identifier_to, ++ uint16_t &group_identifier_to, + +- int8_t &scene_identifier_to ++ uint8_t &scene_identifier_to + + ) { + +@@ -2614,25 +2614,25 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + return; + } + +- group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint8_t * >(); ++ group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint16_t >(); + if (jsn.at("SceneIdentifierFrom").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_from = jsn.at("SceneIdentifierFrom").get< int8_t >(); ++ scene_identifier_from = jsn.at("SceneIdentifierFrom").get< uint8_t >(); + if (jsn.at("GroupIdentifierTo").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- group_identifier_to = jsn.at("GroupIdentifierTo").get< uint8_t * >(); ++ group_identifier_to = jsn.at("GroupIdentifierTo").get< uint16_t >(); + if (jsn.at("SceneIdentifierTo").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_to = jsn.at("SceneIdentifierTo").get< int8_t >(); ++ scene_identifier_to = jsn.at("SceneIdentifierTo").get< uint8_t >(); + } + + +@@ -2682,9 +2682,9 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &group_identifier_from, ++ uint16_t &group_identifier_from, + +- int8_t &scene_identifier_from ++ uint8_t &scene_identifier_from + + ) { + +@@ -2704,13 +2704,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + return; + } + +- group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint8_t * >(); ++ group_identifier_from = jsn.at("GroupIdentifierFrom").get< uint16_t >(); + if (jsn.at("SceneIdentifierFrom").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scene_identifier_from = jsn.at("SceneIdentifierFrom").get< int8_t >(); ++ scene_identifier_from = jsn.at("SceneIdentifierFrom").get< uint8_t >(); + } + + +@@ -2829,7 +2829,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + nlohmann::json &jsn, + OffWithEffectEffectIdentifier &effect_identifier, + +- int8_t &effect_variant ++ uint8_t &effect_variant + + ) { + +@@ -2849,7 +2849,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + return; + } + +- effect_variant = jsn.at("EffectVariant").get< int8_t >(); ++ effect_variant = jsn.at("EffectVariant").get< uint8_t >(); + } + + +@@ -2909,9 +2909,9 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + nlohmann::json &jsn, + uint8_t &on_off_control, + +- int16_t &on_time, ++ uint16_t &on_time, + +- int16_t &off_wait_time ++ uint16_t &off_wait_time + + ) { + +@@ -2925,13 +2925,13 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + return; + } + +- on_time = jsn.at("OnTime").get< int16_t >(); ++ on_time = jsn.at("OnTime").get< uint16_t >(); + if (jsn.at("OffWaitTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- off_wait_time = jsn.at("OffWaitTime").get< int16_t >(); ++ off_wait_time = jsn.at("OffWaitTime").get< uint16_t >(); + } + + +@@ -2949,14 +2949,14 @@ void uic_mqtt_dotdot_parse_on_off_write_attributes( + + if (jsn.find("OnTime") != jsn.end()) { + +- new_state.on_time = jsn.at("OnTime").get(); ++ new_state.on_time = jsn.at("OnTime").get(); + + new_updated_state.on_time = true; + } + + if (jsn.find("OffWaitTime") != jsn.end()) { + +- new_state.off_wait_time = jsn.at("OffWaitTime").get(); ++ new_state.off_wait_time = jsn.at("OffWaitTime").get(); + + new_updated_state.off_wait_time = true; + } +@@ -3021,9 +3021,9 @@ std::string get_json_payload_for_level_move_to_level_command( + + void uic_mqtt_dotdot_parse_level_move_to_level( + nlohmann::json &jsn, +- int8_t &level, ++ uint8_t &level, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -3036,13 +3036,13 @@ void uic_mqtt_dotdot_parse_level_move_to_level( + return; + } + +- level = jsn.at("Level").get< int8_t >(); ++ level = jsn.at("Level").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3110,7 +3110,7 @@ void uic_mqtt_dotdot_parse_level_move( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -3134,7 +3134,7 @@ void uic_mqtt_dotdot_parse_level_move( + return; + } + +- rate = jsn.at("Rate").get< int8_t >(); ++ rate = jsn.at("Rate").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3206,9 +3206,9 @@ void uic_mqtt_dotdot_parse_level_step( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -3232,13 +3232,13 @@ void uic_mqtt_dotdot_parse_level_step( + return; + } + +- step_size = jsn.at("StepSize").get< int8_t >(); ++ step_size = jsn.at("StepSize").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3345,9 +3345,9 @@ std::string get_json_payload_for_level_move_to_level_with_on_off_command( + + void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + nlohmann::json &jsn, +- int8_t &level, ++ uint8_t &level, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -3360,13 +3360,13 @@ void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + return; + } + +- level = jsn.at("Level").get< int8_t >(); ++ level = jsn.at("Level").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3434,7 +3434,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -3458,7 +3458,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + return; + } + +- rate = jsn.at("Rate").get< int8_t >(); ++ rate = jsn.at("Rate").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3530,9 +3530,9 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -3556,13 +3556,13 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + return; + } + +- step_size = jsn.at("StepSize").get< int8_t >(); ++ step_size = jsn.at("StepSize").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -3653,7 +3653,7 @@ std::string get_json_payload_for_level_move_to_closest_frequency_command( + + void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + nlohmann::json &jsn, +- int16_t &frequency ++ uint16_t &frequency + + ) { + +@@ -3662,7 +3662,7 @@ void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + return; + } + +- frequency = jsn.at("Frequency").get< int16_t >(); ++ frequency = jsn.at("Frequency").get< uint16_t >(); + } + + +@@ -3687,42 +3687,42 @@ void uic_mqtt_dotdot_parse_level_write_attributes( + + if (jsn.find("OnOffTransitionTime") != jsn.end()) { + +- new_state.on_off_transition_time = jsn.at("OnOffTransitionTime").get(); ++ new_state.on_off_transition_time = jsn.at("OnOffTransitionTime").get(); + + new_updated_state.on_off_transition_time = true; + } + + if (jsn.find("OnLevel") != jsn.end()) { + +- new_state.on_level = jsn.at("OnLevel").get(); ++ new_state.on_level = jsn.at("OnLevel").get(); + + new_updated_state.on_level = true; + } + + if (jsn.find("OnTransitionTime") != jsn.end()) { + +- new_state.on_transition_time = jsn.at("OnTransitionTime").get(); ++ new_state.on_transition_time = jsn.at("OnTransitionTime").get(); + + new_updated_state.on_transition_time = true; + } + + if (jsn.find("OffTransitionTime") != jsn.end()) { + +- new_state.off_transition_time = jsn.at("OffTransitionTime").get(); ++ new_state.off_transition_time = jsn.at("OffTransitionTime").get(); + + new_updated_state.off_transition_time = true; + } + + if (jsn.find("DefaultMoveRate") != jsn.end()) { + +- new_state.default_move_rate = jsn.at("DefaultMoveRate").get(); ++ new_state.default_move_rate = jsn.at("DefaultMoveRate").get(); + + new_updated_state.default_move_rate = true; + } + + if (jsn.find("StartUpCurrentLevel") != jsn.end()) { + +- new_state.start_up_current_level = jsn.at("StartUpCurrentLevel").get(); ++ new_state.start_up_current_level = jsn.at("StartUpCurrentLevel").get(); + + new_updated_state.start_up_current_level = true; + } +@@ -3773,7 +3773,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint8_t &cluster_identifier ++ uint16_t &cluster_identifier + + ) { + +@@ -3793,7 +3793,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); + } + + +@@ -3839,7 +3839,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint8_t &cluster_identifier ++ uint16_t &cluster_identifier + + ) { + +@@ -3859,7 +3859,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); + } + + +@@ -3945,9 +3945,9 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + + uint8_t &alarm_code, + +- uint8_t &cluster_identifier, ++ uint16_t &cluster_identifier, + +- int32_t &time_stamp ++ uint32_t &time_stamp + + ) { + +@@ -3978,13 +3978,13 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + return; + } + +- cluster_identifier = jsn.at("ClusterIdentifier").get< uint8_t >(); ++ cluster_identifier = jsn.at("ClusterIdentifier").get< uint16_t >(); + if (jsn.at("TimeStamp").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- time_stamp = jsn.at("TimeStamp").get< int32_t >(); ++ time_stamp = jsn.at("TimeStamp").get< uint32_t >(); + } + + +@@ -4056,7 +4056,7 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("Time") != jsn.end()) { + +- new_state.time = jsn.at("Time").get(); ++ new_state.time = jsn.at("Time").get(); + + new_updated_state.time = true; + } +@@ -4077,14 +4077,14 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("DstStart") != jsn.end()) { + +- new_state.dst_start = jsn.at("DstStart").get(); ++ new_state.dst_start = jsn.at("DstStart").get(); + + new_updated_state.dst_start = true; + } + + if (jsn.find("DstEnd") != jsn.end()) { + +- new_state.dst_end = jsn.at("DstEnd").get(); ++ new_state.dst_end = jsn.at("DstEnd").get(); + + new_updated_state.dst_end = true; + } +@@ -4098,7 +4098,7 @@ void uic_mqtt_dotdot_parse_time_write_attributes( + + if (jsn.find("ValidUntilTime") != jsn.end()) { + +- new_state.valid_until_time = jsn.at("ValidUntilTime").get(); ++ new_state.valid_until_time = jsn.at("ValidUntilTime").get(); + + new_updated_state.valid_until_time = true; + } +@@ -4157,7 +4157,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + nlohmann::json &jsn, + bool &start_fast_polling, + +- int16_t &fast_poll_timeout ++ uint16_t &fast_poll_timeout + + ) { + +@@ -4172,7 +4172,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + return; + } + +- fast_poll_timeout = jsn.at("FastPollTimeout").get< int16_t >(); ++ fast_poll_timeout = jsn.at("FastPollTimeout").get< uint16_t >(); + } + + +@@ -4220,7 +4220,7 @@ std::string get_json_payload_for_poll_control_set_long_poll_interval_command( + + void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + nlohmann::json &jsn, +- int32_t &new_long_poll_interval ++ uint32_t &new_long_poll_interval + + ) { + +@@ -4229,7 +4229,7 @@ void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + return; + } + +- new_long_poll_interval = jsn.at("NewLongPollInterval").get< int32_t >(); ++ new_long_poll_interval = jsn.at("NewLongPollInterval").get< uint32_t >(); + } + + +@@ -4258,7 +4258,7 @@ std::string get_json_payload_for_poll_control_set_short_poll_interval_command( + + void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + nlohmann::json &jsn, +- int16_t &new_short_poll_interval ++ uint16_t &new_short_poll_interval + + ) { + +@@ -4267,7 +4267,7 @@ void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + return; + } + +- new_short_poll_interval = jsn.at("NewShortPollInterval").get< int16_t >(); ++ new_short_poll_interval = jsn.at("NewShortPollInterval").get< uint16_t >(); + } + + +@@ -4285,14 +4285,14 @@ void uic_mqtt_dotdot_parse_poll_control_write_attributes( + + if (jsn.find("CheckInInterval") != jsn.end()) { + +- new_state.check_in_interval = jsn.at("CheckInInterval").get(); ++ new_state.check_in_interval = jsn.at("CheckInInterval").get(); + + new_updated_state.check_in_interval = true; + } + + if (jsn.find("FastPollTimeout") != jsn.end()) { + +- new_state.fast_poll_timeout = jsn.at("FastPollTimeout").get(); ++ new_state.fast_poll_timeout = jsn.at("FastPollTimeout").get(); + + new_updated_state.fast_poll_timeout = true; + } +@@ -4322,7 +4322,7 @@ void uic_mqtt_dotdot_parse_shade_configuration_write_attributes( + + if (jsn.find("ClosedLimit") != jsn.end()) { + +- new_state.closed_limit = jsn.at("ClosedLimit").get(); ++ new_state.closed_limit = jsn.at("ClosedLimit").get(); + + new_updated_state.closed_limit = true; + } +@@ -4651,7 +4651,7 @@ std::string get_json_payload_for_door_lock_unlock_with_timeout_command( + + void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + nlohmann::json &jsn, +- int16_t &timeout_in_seconds, ++ uint16_t &timeout_in_seconds, + + std::string &pin_or_rfid_code + +@@ -4662,7 +4662,7 @@ void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + return; + } + +- timeout_in_seconds = jsn.at("TimeoutInSeconds").get< int16_t >(); ++ timeout_in_seconds = jsn.at("TimeoutInSeconds").get< uint16_t >(); + if (jsn.at("PINOrRFIDCode").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4751,7 +4751,7 @@ std::string get_json_payload_for_door_lock_get_log_record_command( + + void uic_mqtt_dotdot_parse_door_lock_get_log_record( + nlohmann::json &jsn, +- int16_t &log_index ++ uint16_t &log_index + + ) { + +@@ -4760,7 +4760,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record( + return; + } + +- log_index = jsn.at("LogIndex").get< int16_t >(); ++ log_index = jsn.at("LogIndex").get< uint16_t >(); + } + + +@@ -4835,17 +4835,17 @@ std::string get_json_payload_for_door_lock_get_log_record_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + nlohmann::json &jsn, +- int16_t &log_entryid, ++ uint16_t &log_entryid, + +- int32_t ×tamp, ++ uint32_t ×tamp, + + GetLogRecordResponseEventType &event_type, + + DrlkOperEventSource &source_operation_event, + +- int8_t &event_id_or_alarm_code, ++ uint8_t &event_id_or_alarm_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin + +@@ -4868,13 +4868,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + return; + } + +- log_entryid = jsn.at("LogEntryID").get< int16_t >(); ++ log_entryid = jsn.at("LogEntryID").get< uint16_t >(); + if (jsn.at("Timestamp").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- timestamp = jsn.at("Timestamp").get< int32_t >(); ++ timestamp = jsn.at("Timestamp").get< uint32_t >(); + if (jsn.at("EventType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4890,13 +4890,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + return; + } + +- event_id_or_alarm_code = jsn.at("EventIDOrAlarmCode").get< int8_t >(); ++ event_id_or_alarm_code = jsn.at("EventIDOrAlarmCode").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -4965,7 +4965,7 @@ std::string get_json_payload_for_door_lock_set_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status, + +@@ -4992,7 +4992,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5091,7 +5091,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -5100,7 +5100,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -5163,7 +5163,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status, + +@@ -5190,7 +5190,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5235,7 +5235,7 @@ std::string get_json_payload_for_door_lock_clear_pin_code_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -5244,7 +5244,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -5415,7 +5415,7 @@ std::string get_json_payload_for_door_lock_set_user_status_command( + + void uic_mqtt_dotdot_parse_door_lock_set_user_status( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status + +@@ -5432,7 +5432,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user_status( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5520,7 +5520,7 @@ std::string get_json_payload_for_door_lock_get_user_status_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_status( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -5529,7 +5529,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_status( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -5573,7 +5573,7 @@ std::string get_json_payload_for_door_lock_get_user_status_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status + +@@ -5590,7 +5590,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5650,19 +5650,19 @@ std::string get_json_payload_for_door_lock_set_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid, ++ uint16_t &userid, + + uint8_t &days_mask, + +- int8_t &start_hour, ++ uint8_t &start_hour, + +- int8_t &start_minute, ++ uint8_t &start_minute, + +- int8_t &end_hour, ++ uint8_t &end_hour, + +- int8_t &end_minute ++ uint8_t &end_minute + + ) { + +@@ -5671,13 +5671,13 @@ void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("DaysMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5688,25 +5688,25 @@ void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + return; + } + +- start_hour = jsn.at("StartHour").get< int8_t >(); ++ start_hour = jsn.at("StartHour").get< uint8_t >(); + if (jsn.at("StartMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_minute = jsn.at("StartMinute").get< int8_t >(); ++ start_minute = jsn.at("StartMinute").get< uint8_t >(); + if (jsn.at("EndHour").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_hour = jsn.at("EndHour").get< int8_t >(); ++ end_hour = jsn.at("EndHour").get< uint8_t >(); + if (jsn.at("EndMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_minute = jsn.at("EndMinute").get< int8_t >(); ++ end_minute = jsn.at("EndMinute").get< uint8_t >(); + } + + +@@ -5793,9 +5793,9 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -5804,13 +5804,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -5880,21 +5880,21 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_response_command + + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + nlohmann::json &jsn, +- int8_t &scheduleid, ++ uint8_t &scheduleid, + +- int16_t &userid, ++ uint16_t &userid, + + zclStatus &status, + + uint8_t &days_mask, + +- int8_t &start_hour, ++ uint8_t &start_hour, + +- int8_t &start_minute, ++ uint8_t &start_minute, + +- int8_t &end_hour, ++ uint8_t &end_hour, + +- int8_t &end_minute ++ uint8_t &end_minute + + ) { + +@@ -5909,13 +5909,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< int8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -5931,25 +5931,25 @@ void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + return; + } + +- start_hour = jsn.at("StartHour").get< int8_t >(); ++ start_hour = jsn.at("StartHour").get< uint8_t >(); + if (jsn.at("StartMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_minute = jsn.at("StartMinute").get< int8_t >(); ++ start_minute = jsn.at("StartMinute").get< uint8_t >(); + if (jsn.at("EndHour").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_hour = jsn.at("EndHour").get< int8_t >(); ++ end_hour = jsn.at("EndHour").get< uint8_t >(); + if (jsn.at("EndMinute").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- end_minute = jsn.at("EndMinute").get< int8_t >(); ++ end_minute = jsn.at("EndMinute").get< uint8_t >(); + } + + +@@ -5982,9 +5982,9 @@ std::string get_json_payload_for_door_lock_clear_weekday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -5993,13 +5993,13 @@ void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -6094,13 +6094,13 @@ std::string get_json_payload_for_door_lock_set_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid, ++ uint16_t &userid, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time ++ uint32_t &local_end_time + + ) { + +@@ -6109,25 +6109,25 @@ void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("LocalStartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< int32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< int32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); + } + + +@@ -6214,9 +6214,9 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -6225,13 +6225,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -6287,15 +6287,15 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_response_comman + + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + nlohmann::json &jsn, +- int8_t &scheduleid, ++ uint8_t &scheduleid, + +- int16_t &userid, ++ uint16_t &userid, + + zclStatus &status, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time ++ uint32_t &local_end_time + + ) { + +@@ -6310,13 +6310,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< int8_t >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6327,13 +6327,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< int32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< int32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); + } + + +@@ -6366,9 +6366,9 @@ std::string get_json_payload_for_door_lock_clear_year_day_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -6377,13 +6377,13 @@ void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + return; + } + +- scheduleid = jsn.at("ScheduleID").get< uint8_t * >(); ++ scheduleid = jsn.at("ScheduleID").get< uint8_t >(); + if (jsn.at("UserID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -6489,11 +6489,11 @@ std::string get_json_payload_for_door_lock_set_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid, ++ uint8_t &holiday_scheduleid, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time, ++ uint32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -6510,19 +6510,19 @@ void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); + if (jsn.at("LocalStartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< int32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< int32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); + if (jsn.at("OperatingModeDuringHoliday").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6610,7 +6610,7 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid ++ uint8_t &holiday_scheduleid + + ) { + +@@ -6619,7 +6619,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); + } + + +@@ -6686,13 +6686,13 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_response_command + + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + nlohmann::json &jsn, +- int8_t &holiday_scheduleid, ++ uint8_t &holiday_scheduleid, + + zclStatus &status, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time, ++ uint32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -6715,7 +6715,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< int8_t >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6726,13 +6726,13 @@ void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + return; + } + +- local_start_time = jsn.at("LocalStartTime").get< int32_t >(); ++ local_start_time = jsn.at("LocalStartTime").get< uint32_t >(); + if (jsn.at("LocalEndTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- local_end_time = jsn.at("LocalEndTime").get< int32_t >(); ++ local_end_time = jsn.at("LocalEndTime").get< uint32_t >(); + if (jsn.at("OperatingModeDuringHoliday").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6766,7 +6766,7 @@ std::string get_json_payload_for_door_lock_clear_holiday_schedule_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid ++ uint8_t &holiday_scheduleid + + ) { + +@@ -6775,7 +6775,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + return; + } + +- holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t * >(); ++ holiday_scheduleid = jsn.at("HolidayScheduleID").get< uint8_t >(); + } + + +@@ -6873,7 +6873,7 @@ std::string get_json_payload_for_door_lock_set_user_type_command( + + void uic_mqtt_dotdot_parse_door_lock_set_user_type( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkUserType &user_type + +@@ -6890,7 +6890,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user_type( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -6978,7 +6978,7 @@ std::string get_json_payload_for_door_lock_get_user_type_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_type( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -6987,7 +6987,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_type( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -7031,7 +7031,7 @@ std::string get_json_payload_for_door_lock_get_user_type_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserType &user_type + +@@ -7048,7 +7048,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7116,7 +7116,7 @@ std::string get_json_payload_for_door_lock_set_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status, + +@@ -7143,7 +7143,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7242,7 +7242,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -7251,7 +7251,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -7314,7 +7314,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_response_command( + + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status, + +@@ -7341,7 +7341,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7386,7 +7386,7 @@ std::string get_json_payload_for_door_lock_clear_rfid_code_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ) { + +@@ -7395,7 +7395,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + return; + } + +- userid = jsn.at("UserID").get< uint8_t * >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + } + + +@@ -7621,11 +7621,11 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + nlohmann::json &jsn, + DataOperationTypeEnum &operation_type, + +- int16_t &user_index, ++ uint16_t &user_index, + + std::string &user_name, + +- int32_t &user_uniqueid, ++ uint32_t &user_uniqueid, + + DrlkSettableUserStatus &user_status, + +@@ -7669,7 +7669,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + return; + } + +- user_index = jsn.at("UserIndex").get< int16_t >(); ++ user_index = jsn.at("UserIndex").get< uint16_t >(); + if (jsn.at("UserName").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7681,7 +7681,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int32_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint32_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7725,7 +7725,7 @@ std::string get_json_payload_for_door_lock_get_user_command( + + void uic_mqtt_dotdot_parse_door_lock_get_user( + nlohmann::json &jsn, +- int16_t &user_index ++ uint16_t &user_index + + ) { + +@@ -7734,7 +7734,7 @@ void uic_mqtt_dotdot_parse_door_lock_get_user( + return; + } + +- user_index = jsn.at("UserIndex").get< int16_t >(); ++ user_index = jsn.at("UserIndex").get< uint16_t >(); + } + + +@@ -7782,7 +7782,7 @@ std::string get_json_payload_for_door_lock_clear_user_command( + + void uic_mqtt_dotdot_parse_door_lock_clear_user( + nlohmann::json &jsn, +- int16_t &user_index ++ uint16_t &user_index + + ) { + +@@ -7791,7 +7791,7 @@ void uic_mqtt_dotdot_parse_door_lock_clear_user( + return; + } + +- user_index = jsn.at("UserIndex").get< int16_t >(); ++ user_index = jsn.at("UserIndex").get< uint16_t >(); + } + + +@@ -7866,11 +7866,11 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + + OperatingEventNotificationOperationEventCode &operation_event_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin, + +- int32_t &local_time, ++ uint32_t &local_time, + + std::string &data + +@@ -7903,7 +7903,7 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -7915,7 +7915,7 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + return; + } + +- local_time = jsn.at("LocalTime").get< int32_t >(); ++ local_time = jsn.at("LocalTime").get< uint32_t >(); + if (jsn.at("Data").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8026,7 +8026,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventCode &program_event_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin, + +@@ -8034,7 +8034,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + DrlkUserStatus &user_status, + +- int32_t &local_time, ++ uint32_t &local_time, + + std::string &data + +@@ -8079,7 +8079,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + return; + } + +- userid = jsn.at("UserID").get< int16_t >(); ++ userid = jsn.at("UserID").get< uint16_t >(); + if (jsn.at("PIN").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8101,7 +8101,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + return; + } + +- local_time = jsn.at("LocalTime").get< int32_t >(); ++ local_time = jsn.at("LocalTime").get< uint32_t >(); + if (jsn.at("Data").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8195,7 +8195,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + + std::string &credential_data, + +- int16_t &user_index, ++ uint16_t &user_index, + + DrlkSettableUserStatus &user_status, + +@@ -8243,7 +8243,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + return; + } + +- user_index = jsn.at("UserIndex").get< int16_t >(); ++ user_index = jsn.at("UserIndex").get< uint16_t >(); + if (jsn.at("UserStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -8423,21 +8423,21 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("DoorOpenEvents") != jsn.end()) { + +- new_state.door_open_events = jsn.at("DoorOpenEvents").get(); ++ new_state.door_open_events = jsn.at("DoorOpenEvents").get(); + + new_updated_state.door_open_events = true; + } + + if (jsn.find("DoorClosedEvents") != jsn.end()) { + +- new_state.door_closed_events = jsn.at("DoorClosedEvents").get(); ++ new_state.door_closed_events = jsn.at("DoorClosedEvents").get(); + + new_updated_state.door_closed_events = true; + } + + if (jsn.find("OpenPeriod") != jsn.end()) { + +- new_state.open_period = jsn.at("OpenPeriod").get(); ++ new_state.open_period = jsn.at("OpenPeriod").get(); + + new_updated_state.open_period = true; + } +@@ -8458,21 +8458,21 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("LEDSettings") != jsn.end()) { + +- new_state.led_settings = jsn.at("LEDSettings").get(); ++ new_state.led_settings = jsn.at("LEDSettings").get(); + + new_updated_state.led_settings = true; + } + + if (jsn.find("AutoRelockTime") != jsn.end()) { + +- new_state.auto_relock_time = jsn.at("AutoRelockTime").get(); ++ new_state.auto_relock_time = jsn.at("AutoRelockTime").get(); + + new_updated_state.auto_relock_time = true; + } + + if (jsn.find("SoundVolume") != jsn.end()) { + +- new_state.sound_volume = jsn.at("SoundVolume").get(); ++ new_state.sound_volume = jsn.at("SoundVolume").get(); + + new_updated_state.sound_volume = true; + } +@@ -8529,14 +8529,14 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("WrongCodeEntryLimit") != jsn.end()) { + +- new_state.wrong_code_entry_limit = jsn.at("WrongCodeEntryLimit").get(); ++ new_state.wrong_code_entry_limit = jsn.at("WrongCodeEntryLimit").get(); + + new_updated_state.wrong_code_entry_limit = true; + } + + if (jsn.find("UserCodeTemporaryDisableTime") != jsn.end()) { + +- new_state.user_code_temporary_disable_time = jsn.at("UserCodeTemporaryDisableTime").get(); ++ new_state.user_code_temporary_disable_time = jsn.at("UserCodeTemporaryDisableTime").get(); + + new_updated_state.user_code_temporary_disable_time = true; + } +@@ -8557,7 +8557,7 @@ void uic_mqtt_dotdot_parse_door_lock_write_attributes( + + if (jsn.find("ExpiringUserTimeout") != jsn.end()) { + +- new_state.expiring_user_timeout = jsn.at("ExpiringUserTimeout").get(); ++ new_state.expiring_user_timeout = jsn.at("ExpiringUserTimeout").get(); + + new_updated_state.expiring_user_timeout = true; + } +@@ -8704,7 +8704,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_value_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + nlohmann::json &jsn, +- int16_t &lift_value ++ uint16_t &lift_value + + ) { + +@@ -8713,7 +8713,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + return; + } + +- lift_value = jsn.at("LiftValue").get< int16_t >(); ++ lift_value = jsn.at("LiftValue").get< uint16_t >(); + } + + +@@ -8742,7 +8742,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_percentage_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + nlohmann::json &jsn, +- int8_t &percentage_lift_value ++ uint8_t &percentage_lift_value + + ) { + +@@ -8751,7 +8751,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + return; + } + +- percentage_lift_value = jsn.at("PercentageLiftValue").get< int8_t >(); ++ percentage_lift_value = jsn.at("PercentageLiftValue").get< uint8_t >(); + } + + +@@ -8780,7 +8780,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_value_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + nlohmann::json &jsn, +- int16_t &tilt_value ++ uint16_t &tilt_value + + ) { + +@@ -8789,7 +8789,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + return; + } + +- tilt_value = jsn.at("TiltValue").get< int16_t >(); ++ tilt_value = jsn.at("TiltValue").get< uint16_t >(); + } + + +@@ -8818,7 +8818,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_percentage_command( + + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + nlohmann::json &jsn, +- int8_t &percentage_tilt_value ++ uint8_t &percentage_tilt_value + + ) { + +@@ -8827,7 +8827,7 @@ void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + return; + } + +- percentage_tilt_value = jsn.at("PercentageTiltValue").get< int8_t >(); ++ percentage_tilt_value = jsn.at("PercentageTiltValue").get< uint8_t >(); + } + + +@@ -8845,21 +8845,21 @@ void uic_mqtt_dotdot_parse_window_covering_write_attributes( + + if (jsn.find("VelocityLift") != jsn.end()) { + +- new_state.velocity_lift = jsn.at("VelocityLift").get(); ++ new_state.velocity_lift = jsn.at("VelocityLift").get(); + + new_updated_state.velocity_lift = true; + } + + if (jsn.find("AccelerationTimeLift") != jsn.end()) { + +- new_state.acceleration_time_lift = jsn.at("AccelerationTimeLift").get(); ++ new_state.acceleration_time_lift = jsn.at("AccelerationTimeLift").get(); + + new_updated_state.acceleration_time_lift = true; + } + + if (jsn.find("DecelerationTimeLift") != jsn.end()) { + +- new_state.deceleration_time_lift = jsn.at("DecelerationTimeLift").get(); ++ new_state.deceleration_time_lift = jsn.at("DecelerationTimeLift").get(); + + new_updated_state.deceleration_time_lift = true; + } +@@ -8900,7 +8900,7 @@ std::string get_json_payload_for_barrier_control_go_to_percent_command( + + void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + nlohmann::json &jsn, +- int8_t &percent_open ++ uint8_t &percent_open + + ) { + +@@ -8909,7 +8909,7 @@ void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + return; + } + +- percent_open = jsn.at("PercentOpen").get< int8_t >(); ++ percent_open = jsn.at("PercentOpen").get< uint8_t >(); + } + + +@@ -8946,42 +8946,42 @@ void uic_mqtt_dotdot_parse_barrier_control_write_attributes( + + if (jsn.find("OpenEvents") != jsn.end()) { + +- new_state.open_events = jsn.at("OpenEvents").get(); ++ new_state.open_events = jsn.at("OpenEvents").get(); + + new_updated_state.open_events = true; + } + + if (jsn.find("CloseEvents") != jsn.end()) { + +- new_state.close_events = jsn.at("CloseEvents").get(); ++ new_state.close_events = jsn.at("CloseEvents").get(); + + new_updated_state.close_events = true; + } + + if (jsn.find("CommandOpenEvents") != jsn.end()) { + +- new_state.command_open_events = jsn.at("CommandOpenEvents").get(); ++ new_state.command_open_events = jsn.at("CommandOpenEvents").get(); + + new_updated_state.command_open_events = true; + } + + if (jsn.find("CommandCloseEvents") != jsn.end()) { + +- new_state.command_close_events = jsn.at("CommandCloseEvents").get(); ++ new_state.command_close_events = jsn.at("CommandCloseEvents").get(); + + new_updated_state.command_close_events = true; + } + + if (jsn.find("OpenPeriod") != jsn.end()) { + +- new_state.open_period = jsn.at("OpenPeriod").get(); ++ new_state.open_period = jsn.at("OpenPeriod").get(); + + new_updated_state.open_period = true; + } + + if (jsn.find("ClosePeriod") != jsn.end()) { + +- new_state.close_period = jsn.at("ClosePeriod").get(); ++ new_state.close_period = jsn.at("ClosePeriod").get(); + + new_updated_state.close_period = true; + } +@@ -9004,14 +9004,14 @@ void uic_mqtt_dotdot_parse_pump_configuration_and_control_write_attributes( + + if (jsn.find("LifetimeRunningHours") != jsn.end()) { + +- new_state.lifetime_running_hours = jsn.at("LifetimeRunningHours").get(); ++ new_state.lifetime_running_hours = jsn.at("LifetimeRunningHours").get(); + + new_updated_state.lifetime_running_hours = true; + } + + if (jsn.find("Power") != jsn.end()) { + +- new_state.power = jsn.at("Power").get(); ++ new_state.power = jsn.at("Power").get(); + + new_updated_state.power = true; + } +@@ -9383,17 +9383,17 @@ std::string get_json_payload_for_thermostat_get_relay_status_log_response_comman + + void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + nlohmann::json &jsn, +- int16_t &time_of_day, ++ uint16_t &time_of_day, + + uint8_t &relay_status, + + int16_t &local_temperature, + +- int8_t &humidity_percentage, ++ uint8_t &humidity_percentage, + + int16_t &set_point, + +- int16_t &unread_entries ++ uint16_t &unread_entries + + ) { + +@@ -9402,7 +9402,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- time_of_day = jsn.at("TimeOfDay").get< int16_t >(); ++ time_of_day = jsn.at("TimeOfDay").get< uint16_t >(); + if (jsn.at("RelayStatus").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -9419,7 +9419,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- humidity_percentage = jsn.at("HumidityPercentage").get< int8_t >(); ++ humidity_percentage = jsn.at("HumidityPercentage").get< uint8_t >(); + if (jsn.at("SetPoint").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -9431,7 +9431,7 @@ void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + return; + } + +- unread_entries = jsn.at("UnreadEntries").get< int16_t >(); ++ unread_entries = jsn.at("UnreadEntries").get< uint16_t >(); + } + + +@@ -9668,7 +9668,7 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("TemperatureSetpointHoldDuration") != jsn.end()) { + +- new_state.temperature_setpoint_hold_duration = jsn.at("TemperatureSetpointHoldDuration").get(); ++ new_state.temperature_setpoint_hold_duration = jsn.at("TemperatureSetpointHoldDuration").get(); + + new_updated_state.temperature_setpoint_hold_duration = true; + } +@@ -9682,21 +9682,21 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("OccupiedSetback") != jsn.end()) { + +- new_state.occupied_setback = jsn.at("OccupiedSetback").get(); ++ new_state.occupied_setback = jsn.at("OccupiedSetback").get(); + + new_updated_state.occupied_setback = true; + } + + if (jsn.find("UnoccupiedSetback") != jsn.end()) { + +- new_state.unoccupied_setback = jsn.at("UnoccupiedSetback").get(); ++ new_state.unoccupied_setback = jsn.at("UnoccupiedSetback").get(); + + new_updated_state.unoccupied_setback = true; + } + + if (jsn.find("EmergencyHeatDelta") != jsn.end()) { + +- new_state.emergency_heat_delta = jsn.at("EmergencyHeatDelta").get(); ++ new_state.emergency_heat_delta = jsn.at("EmergencyHeatDelta").get(); + + new_updated_state.emergency_heat_delta = true; + } +@@ -9718,7 +9718,7 @@ void uic_mqtt_dotdot_parse_thermostat_write_attributes( + + if (jsn.find("ACCapacity") != jsn.end()) { + +- new_state.ac_capacity = jsn.at("ACCapacity").get(); ++ new_state.ac_capacity = jsn.at("ACCapacity").get(); + + new_updated_state.ac_capacity = true; + } +@@ -9854,7 +9854,7 @@ void uic_mqtt_dotdot_parse_dehumidification_control_write_attributes( + + if (jsn.find("RHDehumidificationSetpoint") != jsn.end()) { + +- new_state.rh_dehumidification_setpoint = jsn.at("RHDehumidificationSetpoint").get(); ++ new_state.rh_dehumidification_setpoint = jsn.at("RHDehumidificationSetpoint").get(); + + new_updated_state.rh_dehumidification_setpoint = true; + } +@@ -9891,14 +9891,14 @@ void uic_mqtt_dotdot_parse_dehumidification_control_write_attributes( + + if (jsn.find("DehumidificationHysteresis") != jsn.end()) { + +- new_state.dehumidification_hysteresis = jsn.at("DehumidificationHysteresis").get(); ++ new_state.dehumidification_hysteresis = jsn.at("DehumidificationHysteresis").get(); + + new_updated_state.dehumidification_hysteresis = true; + } + + if (jsn.find("DehumidificationMaxCool") != jsn.end()) { + +- new_state.dehumidification_max_cool = jsn.at("DehumidificationMaxCool").get(); ++ new_state.dehumidification_max_cool = jsn.at("DehumidificationMaxCool").get(); + + new_updated_state.dehumidification_max_cool = true; + } +@@ -10039,11 +10039,11 @@ std::string get_json_payload_for_color_control_move_to_hue_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_hue( + nlohmann::json &jsn, +- int8_t &hue, ++ uint8_t &hue, + + CCDirection &direction, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10062,7 +10062,7 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue( + return; + } + +- hue = jsn.at("Hue").get< int8_t >(); ++ hue = jsn.at("Hue").get< uint8_t >(); + if (jsn.at("Direction").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10073,7 +10073,7 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue( + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10141,7 +10141,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -10165,7 +10165,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + return; + } + +- rate = jsn.at("Rate").get< int8_t >(); ++ rate = jsn.at("Rate").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10237,9 +10237,9 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int8_t &transition_time, ++ uint8_t &transition_time, + + uint8_t &options_mask, + +@@ -10263,13 +10263,13 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + return; + } + +- step_size = jsn.at("StepSize").get< int8_t >(); ++ step_size = jsn.at("StepSize").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int8_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10324,9 +10324,9 @@ std::string get_json_payload_for_color_control_move_to_saturation_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + nlohmann::json &jsn, +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10339,13 +10339,13 @@ void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + return; + } + +- saturation = jsn.at("Saturation").get< int8_t >(); ++ saturation = jsn.at("Saturation").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10413,7 +10413,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -10437,7 +10437,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + return; + } + +- rate = jsn.at("Rate").get< int8_t >(); ++ rate = jsn.at("Rate").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10509,9 +10509,9 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int8_t &transition_time, ++ uint8_t &transition_time, + + uint8_t &options_mask, + +@@ -10535,13 +10535,13 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + return; + } + +- step_size = jsn.at("StepSize").get< int8_t >(); ++ step_size = jsn.at("StepSize").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int8_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint8_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10600,11 +10600,11 @@ std::string get_json_payload_for_color_control_move_to_hue_and_saturation_comman + + void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + nlohmann::json &jsn, +- int8_t &hue, ++ uint8_t &hue, + +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10617,19 +10617,19 @@ void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + return; + } + +- hue = jsn.at("Hue").get< int8_t >(); ++ hue = jsn.at("Hue").get< uint8_t >(); + if (jsn.at("Saturation").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- saturation = jsn.at("Saturation").get< int8_t >(); ++ saturation = jsn.at("Saturation").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10688,11 +10688,11 @@ std::string get_json_payload_for_color_control_move_to_color_command( + + void uic_mqtt_dotdot_parse_color_control_move_to_color( + nlohmann::json &jsn, +- int16_t &colorx, ++ uint16_t &colorx, + +- int16_t &colory, ++ uint16_t &colory, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10705,19 +10705,19 @@ void uic_mqtt_dotdot_parse_color_control_move_to_color( + return; + } + +- colorx = jsn.at("ColorX").get< int16_t >(); ++ colorx = jsn.at("ColorX").get< uint16_t >(); + if (jsn.at("ColorY").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- colory = jsn.at("ColorY").get< int16_t >(); ++ colory = jsn.at("ColorY").get< uint16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10856,7 +10856,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + + int16_t &stepy, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10881,7 +10881,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -10936,9 +10936,9 @@ std::string get_json_payload_for_color_control_move_to_color_temperature_command + + void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + nlohmann::json &jsn, +- int16_t &color_temperature_mireds, ++ uint16_t &color_temperature_mireds, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -10951,13 +10951,13 @@ void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + return; + } + +- color_temperature_mireds = jsn.at("ColorTemperatureMireds").get< int16_t >(); ++ color_temperature_mireds = jsn.at("ColorTemperatureMireds").get< uint16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11027,11 +11027,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_command( + + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + nlohmann::json &jsn, +- int16_t &enhanced_hue, ++ uint16_t &enhanced_hue, + + CCDirection &direction, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -11050,7 +11050,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + return; + } + +- enhanced_hue = jsn.at("EnhancedHue").get< int16_t >(); ++ enhanced_hue = jsn.at("EnhancedHue").get< uint16_t >(); + if (jsn.at("Direction").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11061,7 +11061,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11129,7 +11129,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int16_t &rate, ++ uint16_t &rate, + + uint8_t &options_mask, + +@@ -11153,7 +11153,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + return; + } + +- rate = jsn.at("Rate").get< int16_t >(); ++ rate = jsn.at("Rate").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11225,9 +11225,9 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int16_t &step_size, ++ uint16_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -11251,13 +11251,13 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + return; + } + +- step_size = jsn.at("StepSize").get< int16_t >(); ++ step_size = jsn.at("StepSize").get< uint16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11316,11 +11316,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_and_saturati + + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + nlohmann::json &jsn, +- int16_t &enhanced_hue, ++ uint16_t &enhanced_hue, + +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -11333,19 +11333,19 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + return; + } + +- enhanced_hue = jsn.at("EnhancedHue").get< int16_t >(); ++ enhanced_hue = jsn.at("EnhancedHue").get< uint16_t >(); + if (jsn.at("Saturation").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- saturation = jsn.at("Saturation").get< int8_t >(); ++ saturation = jsn.at("Saturation").get< uint8_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11442,9 +11442,9 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + + CCColorLoopDirection &direction, + +- int16_t &time, ++ uint16_t &time, + +- int16_t &start_hue, ++ uint16_t &start_hue, + + uint8_t &options_mask, + +@@ -11484,13 +11484,13 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + return; + } + +- time = jsn.at("Time").get< int16_t >(); ++ time = jsn.at("Time").get< uint16_t >(); + if (jsn.at("StartHue").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_hue = jsn.at("StartHue").get< int16_t >(); ++ start_hue = jsn.at("StartHue").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11618,11 +11618,11 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int16_t &rate, ++ uint16_t &rate, + +- uint8_t * &color_temperature_minimum_mireds, ++ uint16_t &color_temperature_minimum_mireds, + +- uint8_t * &color_temperature_maximum_mireds, ++ uint16_t &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -11646,19 +11646,19 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + return; + } + +- rate = jsn.at("Rate").get< int16_t >(); ++ rate = jsn.at("Rate").get< uint16_t >(); + if (jsn.at("ColorTemperatureMinimumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint8_t * >(); ++ color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint16_t >(); + if (jsn.at("ColorTemperatureMaximumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint8_t * >(); ++ color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11738,13 +11738,13 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int16_t &step_size, ++ uint16_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + +- uint8_t * &color_temperature_minimum_mireds, ++ uint16_t &color_temperature_minimum_mireds, + +- uint8_t * &color_temperature_maximum_mireds, ++ uint16_t &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -11768,25 +11768,25 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + return; + } + +- step_size = jsn.at("StepSize").get< int16_t >(); ++ step_size = jsn.at("StepSize").get< uint16_t >(); + if (jsn.at("TransitionTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- transition_time = jsn.at("TransitionTime").get< int16_t >(); ++ transition_time = jsn.at("TransitionTime").get< uint16_t >(); + if (jsn.at("ColorTemperatureMinimumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint8_t * >(); ++ color_temperature_minimum_mireds = jsn.at("ColorTemperatureMinimumMireds").get< uint16_t >(); + if (jsn.at("ColorTemperatureMaximumMireds").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint8_t * >(); ++ color_temperature_maximum_mireds = jsn.at("ColorTemperatureMaximumMireds").get< uint16_t >(); + if (jsn.at("OptionsMask").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -11821,84 +11821,84 @@ void uic_mqtt_dotdot_parse_color_control_write_attributes( + + if (jsn.find("WhitePointX") != jsn.end()) { + +- new_state.white_pointx = jsn.at("WhitePointX").get(); ++ new_state.white_pointx = jsn.at("WhitePointX").get(); + + new_updated_state.white_pointx = true; + } + + if (jsn.find("WhitePointY") != jsn.end()) { + +- new_state.white_pointy = jsn.at("WhitePointY").get(); ++ new_state.white_pointy = jsn.at("WhitePointY").get(); + + new_updated_state.white_pointy = true; + } + + if (jsn.find("ColorPointRX") != jsn.end()) { + +- new_state.color_pointrx = jsn.at("ColorPointRX").get(); ++ new_state.color_pointrx = jsn.at("ColorPointRX").get(); + + new_updated_state.color_pointrx = true; + } + + if (jsn.find("ColorPointRY") != jsn.end()) { + +- new_state.color_pointry = jsn.at("ColorPointRY").get(); ++ new_state.color_pointry = jsn.at("ColorPointRY").get(); + + new_updated_state.color_pointry = true; + } + + if (jsn.find("ColorPointRIntensity") != jsn.end()) { + +- new_state.color_pointr_intensity = jsn.at("ColorPointRIntensity").get(); ++ new_state.color_pointr_intensity = jsn.at("ColorPointRIntensity").get(); + + new_updated_state.color_pointr_intensity = true; + } + + if (jsn.find("ColorPointGX") != jsn.end()) { + +- new_state.color_pointgx = jsn.at("ColorPointGX").get(); ++ new_state.color_pointgx = jsn.at("ColorPointGX").get(); + + new_updated_state.color_pointgx = true; + } + + if (jsn.find("ColorPointGY") != jsn.end()) { + +- new_state.color_pointgy = jsn.at("ColorPointGY").get(); ++ new_state.color_pointgy = jsn.at("ColorPointGY").get(); + + new_updated_state.color_pointgy = true; + } + + if (jsn.find("ColorPointGIntensity") != jsn.end()) { + +- new_state.color_pointg_intensity = jsn.at("ColorPointGIntensity").get(); ++ new_state.color_pointg_intensity = jsn.at("ColorPointGIntensity").get(); + + new_updated_state.color_pointg_intensity = true; + } + + if (jsn.find("ColorPointBX") != jsn.end()) { + +- new_state.color_pointbx = jsn.at("ColorPointBX").get(); ++ new_state.color_pointbx = jsn.at("ColorPointBX").get(); + + new_updated_state.color_pointbx = true; + } + + if (jsn.find("ColorPointBY") != jsn.end()) { + +- new_state.color_pointby = jsn.at("ColorPointBY").get(); ++ new_state.color_pointby = jsn.at("ColorPointBY").get(); + + new_updated_state.color_pointby = true; + } + + if (jsn.find("ColorPointBIntensity") != jsn.end()) { + +- new_state.color_pointb_intensity = jsn.at("ColorPointBIntensity").get(); ++ new_state.color_pointb_intensity = jsn.at("ColorPointBIntensity").get(); + + new_updated_state.color_pointb_intensity = true; + } + + if (jsn.find("StartUpColorTemperatureMireds") != jsn.end()) { + +- new_state.start_up_color_temperature_mireds = jsn.at("StartUpColorTemperatureMireds").get(); ++ new_state.start_up_color_temperature_mireds = jsn.at("StartUpColorTemperatureMireds").get(); + + new_updated_state.start_up_color_temperature_mireds = true; + } +@@ -11921,42 +11921,42 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("MinLevel") != jsn.end()) { + +- new_state.min_level = jsn.at("MinLevel").get(); ++ new_state.min_level = jsn.at("MinLevel").get(); + + new_updated_state.min_level = true; + } + + if (jsn.find("MaxLevel") != jsn.end()) { + +- new_state.max_level = jsn.at("MaxLevel").get(); ++ new_state.max_level = jsn.at("MaxLevel").get(); + + new_updated_state.max_level = true; + } + + if (jsn.find("PowerOnLevel") != jsn.end()) { + +- new_state.power_on_level = jsn.at("PowerOnLevel").get(); ++ new_state.power_on_level = jsn.at("PowerOnLevel").get(); + + new_updated_state.power_on_level = true; + } + + if (jsn.find("PowerOnFadeTime") != jsn.end()) { + +- new_state.power_on_fade_time = jsn.at("PowerOnFadeTime").get(); ++ new_state.power_on_fade_time = jsn.at("PowerOnFadeTime").get(); + + new_updated_state.power_on_fade_time = true; + } + + if (jsn.find("IntrinsicBallastFactor") != jsn.end()) { + +- new_state.intrinsic_ballast_factor = jsn.at("IntrinsicBallastFactor").get(); ++ new_state.intrinsic_ballast_factor = jsn.at("IntrinsicBallastFactor").get(); + + new_updated_state.intrinsic_ballast_factor = true; + } + + if (jsn.find("BallastFactorAdjustment") != jsn.end()) { + +- new_state.ballast_factor_adjustment = jsn.at("BallastFactorAdjustment").get(); ++ new_state.ballast_factor_adjustment = jsn.at("BallastFactorAdjustment").get(); + + new_updated_state.ballast_factor_adjustment = true; + } +@@ -11977,14 +11977,14 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("LampRatedHours") != jsn.end()) { + +- new_state.lamp_rated_hours = jsn.at("LampRatedHours").get(); ++ new_state.lamp_rated_hours = jsn.at("LampRatedHours").get(); + + new_updated_state.lamp_rated_hours = true; + } + + if (jsn.find("LampBurnHours") != jsn.end()) { + +- new_state.lamp_burn_hours = jsn.at("LampBurnHours").get(); ++ new_state.lamp_burn_hours = jsn.at("LampBurnHours").get(); + + new_updated_state.lamp_burn_hours = true; + } +@@ -11998,7 +11998,7 @@ void uic_mqtt_dotdot_parse_ballast_configuration_write_attributes( + + if (jsn.find("LampBurnHoursTripPoint") != jsn.end()) { + +- new_state.lamp_burn_hours_trip_point = jsn.at("LampBurnHoursTripPoint").get(); ++ new_state.lamp_burn_hours_trip_point = jsn.at("LampBurnHoursTripPoint").get(); + + new_updated_state.lamp_burn_hours_trip_point = true; + } +@@ -12037,7 +12037,7 @@ void uic_mqtt_dotdot_parse_illuminance_level_sensing_write_attributes( + + if (jsn.find("IlluminanceTargetLevel") != jsn.end()) { + +- new_state.illuminance_target_level = jsn.at("IlluminanceTargetLevel").get(); ++ new_state.illuminance_target_level = jsn.at("IlluminanceTargetLevel").get(); + + new_updated_state.illuminance_target_level = true; + } +@@ -12124,63 +12124,63 @@ void uic_mqtt_dotdot_parse_occupancy_sensing_write_attributes( + + if (jsn.find("PIROccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.pir_occupied_to_unoccupied_delay = jsn.at("PIROccupiedToUnoccupiedDelay").get(); ++ new_state.pir_occupied_to_unoccupied_delay = jsn.at("PIROccupiedToUnoccupiedDelay").get(); + + new_updated_state.pir_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("PIRUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.pir_unoccupied_to_occupied_delay = jsn.at("PIRUnoccupiedToOccupiedDelay").get(); ++ new_state.pir_unoccupied_to_occupied_delay = jsn.at("PIRUnoccupiedToOccupiedDelay").get(); + + new_updated_state.pir_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("PIRUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.pir_unoccupied_to_occupied_threshold = jsn.at("PIRUnoccupiedToOccupiedThreshold").get(); ++ new_state.pir_unoccupied_to_occupied_threshold = jsn.at("PIRUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.pir_unoccupied_to_occupied_threshold = true; + } + + if (jsn.find("UltrasonicOccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.ultrasonic_occupied_to_unoccupied_delay = jsn.at("UltrasonicOccupiedToUnoccupiedDelay").get(); ++ new_state.ultrasonic_occupied_to_unoccupied_delay = jsn.at("UltrasonicOccupiedToUnoccupiedDelay").get(); + + new_updated_state.ultrasonic_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("UltrasonicUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.ultrasonic_unoccupied_to_occupied_delay = jsn.at("UltrasonicUnoccupiedToOccupiedDelay").get(); ++ new_state.ultrasonic_unoccupied_to_occupied_delay = jsn.at("UltrasonicUnoccupiedToOccupiedDelay").get(); + + new_updated_state.ultrasonic_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("UltrasonicUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.ultrasonic_unoccupied_to_occupied_threshold = jsn.at("UltrasonicUnoccupiedToOccupiedThreshold").get(); ++ new_state.ultrasonic_unoccupied_to_occupied_threshold = jsn.at("UltrasonicUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.ultrasonic_unoccupied_to_occupied_threshold = true; + } + + if (jsn.find("PhysicalContactOccupiedToUnoccupiedDelay") != jsn.end()) { + +- new_state.physical_contact_occupied_to_unoccupied_delay = jsn.at("PhysicalContactOccupiedToUnoccupiedDelay").get(); ++ new_state.physical_contact_occupied_to_unoccupied_delay = jsn.at("PhysicalContactOccupiedToUnoccupiedDelay").get(); + + new_updated_state.physical_contact_occupied_to_unoccupied_delay = true; + } + + if (jsn.find("PhysicalContactUnoccupiedToOccupiedDelay") != jsn.end()) { + +- new_state.physical_contact_unoccupied_to_occupied_delay = jsn.at("PhysicalContactUnoccupiedToOccupiedDelay").get(); ++ new_state.physical_contact_unoccupied_to_occupied_delay = jsn.at("PhysicalContactUnoccupiedToOccupiedDelay").get(); + + new_updated_state.physical_contact_unoccupied_to_occupied_delay = true; + } + + if (jsn.find("PhysicalContactUnoccupiedToOccupiedThreshold") != jsn.end()) { + +- new_state.physical_contact_unoccupied_to_occupied_threshold = jsn.at("PhysicalContactUnoccupiedToOccupiedThreshold").get(); ++ new_state.physical_contact_unoccupied_to_occupied_threshold = jsn.at("PhysicalContactUnoccupiedToOccupiedThreshold").get(); + + new_updated_state.physical_contact_unoccupied_to_occupied_threshold = true; + } +@@ -12343,7 +12343,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + nlohmann::json &jsn, + ZoneEnrollResponseEnrollResponseCode &enroll_response_code, + +- int8_t &zoneid ++ uint8_t &zoneid + + ) { + +@@ -12363,7 +12363,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + return; + } + +- zoneid = jsn.at("ZoneID").get< int8_t >(); ++ zoneid = jsn.at("ZoneID").get< uint8_t >(); + } + + +@@ -12410,9 +12410,9 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + + uint8_t &extended_status, + +- int8_t &zoneid, ++ uint8_t &zoneid, + +- int16_t &delay ++ uint16_t &delay + + ) { + +@@ -12431,13 +12431,13 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + return; + } + +- zoneid = jsn.at("ZoneID").get< int8_t >(); ++ zoneid = jsn.at("ZoneID").get< uint8_t >(); + if (jsn.at("Delay").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- delay = jsn.at("Delay").get< int16_t >(); ++ delay = jsn.at("Delay").get< uint16_t >(); + } + + +@@ -12502,7 +12502,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + nlohmann::json &jsn, + IasZoneType &zone_type, + +- int16_t &manufacturer_code ++ uint16_t &manufacturer_code + + ) { + +@@ -12522,7 +12522,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + return; + } + +- manufacturer_code = jsn.at("ManufacturerCode").get< int16_t >(); ++ manufacturer_code = jsn.at("ManufacturerCode").get< uint16_t >(); + } + + +@@ -12555,9 +12555,9 @@ std::string get_json_payload_for_ias_zone_initiate_test_mode_command( + + void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + nlohmann::json &jsn, +- int8_t &test_mode_duration, ++ uint8_t &test_mode_duration, + +- int8_t ¤t_zone_sensitivity_level ++ uint8_t ¤t_zone_sensitivity_level + + ) { + +@@ -12566,13 +12566,13 @@ void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + return; + } + +- test_mode_duration = jsn.at("TestModeDuration").get< int8_t >(); ++ test_mode_duration = jsn.at("TestModeDuration").get< uint8_t >(); + if (jsn.at("CurrentZoneSensitivityLevel").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get< int8_t >(); ++ current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get< uint8_t >(); + } + + +@@ -12597,7 +12597,7 @@ void uic_mqtt_dotdot_parse_ias_zone_write_attributes( + + if (jsn.find("CurrentZoneSensitivityLevel") != jsn.end()) { + +- new_state.current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get(); ++ new_state.current_zone_sensitivity_level = jsn.at("CurrentZoneSensitivityLevel").get(); + + new_updated_state.current_zone_sensitivity_level = true; + } +@@ -12658,9 +12658,9 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + nlohmann::json &jsn, + uint8_t &siren_configuration, + +- int16_t &warning_duration, ++ uint16_t &warning_duration, + +- int8_t &strobe_duty_cycle, ++ uint8_t &strobe_duty_cycle, + + IaswdLevel &strobe_level + +@@ -12682,13 +12682,13 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + return; + } + +- warning_duration = jsn.at("WarningDuration").get< int16_t >(); ++ warning_duration = jsn.at("WarningDuration").get< uint16_t >(); + if (jsn.at("StrobeDutyCycle").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- strobe_duty_cycle = jsn.at("StrobeDutyCycle").get< int8_t >(); ++ strobe_duty_cycle = jsn.at("StrobeDutyCycle").get< uint8_t >(); + if (jsn.at("StrobeLevel").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -12750,7 +12750,7 @@ void uic_mqtt_dotdot_parse_iaswd_write_attributes( + + if (jsn.find("MaxDuration") != jsn.end()) { + +- new_state.max_duration = jsn.at("MaxDuration").get(); ++ new_state.max_duration = jsn.at("MaxDuration").get(); + + new_updated_state.max_duration = true; + } +@@ -12809,7 +12809,7 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + json_payload["MaxNumberOfIntervals"] = nlohmann::json(fields->max_number_of_intervals); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["ListOfAttributes"] = std::vector< uint8_t >( ++ json_payload["ListOfAttributes"] = std::vector< uint16_t >( + fields->list_of_attributes, + fields->list_of_attributes + fields->list_of_attributes_count); + +@@ -12825,13 +12825,13 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + + void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + nlohmann::json &jsn, +- int8_t &profile_count, ++ uint8_t &profile_count, + + ProfileIntervalPeriod &profile_interval_period, + +- int8_t &max_number_of_intervals, ++ uint8_t &max_number_of_intervals, + +- std::vector &list_of_attributes ++ std::vector &list_of_attributes + + ) { + +@@ -12846,7 +12846,7 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + return; + } + +- profile_count = jsn.at("ProfileCount").get< int8_t >(); ++ profile_count = jsn.at("ProfileCount").get< uint8_t >(); + if (jsn.at("ProfileIntervalPeriod").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -12857,13 +12857,13 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + return; + } + +- max_number_of_intervals = jsn.at("MaxNumberOfIntervals").get< int8_t >(); ++ max_number_of_intervals = jsn.at("MaxNumberOfIntervals").get< uint8_t >(); + if (jsn.at("ListOfAttributes").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- list_of_attributes = jsn.at("ListOfAttributes").get< std::vector< uint8_t >>(); ++ list_of_attributes = jsn.at("ListOfAttributes").get< std::vector< uint16_t >>(); + } + + +@@ -12939,7 +12939,7 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + json_payload["AttributeId"] = nlohmann::json(fields->attribute_id); + command_with_no_fields = false; + // We assume arrays are Non-enum and non-bitmask (struct, string or scalar) +- json_payload["Intervals"] = std::vector< int8_t >( ++ json_payload["Intervals"] = std::vector< uint8_t >( + fields->intervals, + fields->intervals + fields->intervals_count); + +@@ -12955,17 +12955,17 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_response( + nlohmann::json &jsn, +- uint8_t &start_time, ++ uint32_t &start_time, + + GetMeasurementProfileResponseStatus &status, + + ProfileIntervalPeriod &profile_interval_period, + +- int8_t &number_of_intervals_delivered, ++ uint8_t &number_of_intervals_delivered, + +- uint8_t &attribute_id, ++ uint16_t &attribute_id, + +- std::vector &intervals ++ std::vector &intervals + + ) { + +@@ -12986,7 +12986,7 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_respon + return; + } + +- start_time = jsn.at("StartTime").get< uint8_t >(); ++ start_time = jsn.at("StartTime").get< uint32_t >(); + if (jsn.at("Status").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13002,19 +13002,19 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_respon + return; + } + +- number_of_intervals_delivered = jsn.at("NumberOfIntervalsDelivered").get< int8_t >(); ++ number_of_intervals_delivered = jsn.at("NumberOfIntervalsDelivered").get< uint8_t >(); + if (jsn.at("AttributeId").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- attribute_id = jsn.at("AttributeId").get< uint8_t >(); ++ attribute_id = jsn.at("AttributeId").get< uint16_t >(); + if (jsn.at("Intervals").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- intervals = jsn.at("Intervals").get< std::vector< int8_t >>(); ++ intervals = jsn.at("Intervals").get< std::vector< uint8_t >>(); + } + + +@@ -13051,11 +13051,11 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + nlohmann::json &jsn, +- uint8_t &attributeid, ++ uint16_t &attributeid, + +- uint8_t &start_time, ++ uint32_t &start_time, + +- int8_t &number_of_intervals ++ uint8_t &number_of_intervals + + ) { + +@@ -13064,19 +13064,19 @@ void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + return; + } + +- attributeid = jsn.at("AttributeID").get< uint8_t >(); ++ attributeid = jsn.at("AttributeID").get< uint16_t >(); + if (jsn.at("StartTime").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- start_time = jsn.at("StartTime").get< uint8_t >(); ++ start_time = jsn.at("StartTime").get< uint32_t >(); + if (jsn.at("NumberOfIntervals").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- number_of_intervals = jsn.at("NumberOfIntervals").get< int8_t >(); ++ number_of_intervals = jsn.at("NumberOfIntervals").get< uint8_t >(); + } + + +@@ -13094,49 +13094,49 @@ void uic_mqtt_dotdot_parse_electrical_measurement_write_attributes( + + if (jsn.find("AverageRMSVoltageMeasurementPeriod") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period = jsn.at("AverageRMSVoltageMeasurementPeriod").get(); ++ new_state.average_rms_voltage_measurement_period = jsn.at("AverageRMSVoltageMeasurementPeriod").get(); + + new_updated_state.average_rms_voltage_measurement_period = true; + } + + if (jsn.find("AverageRMSOverVoltageCounter") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter = jsn.at("AverageRMSOverVoltageCounter").get(); ++ new_state.average_rms_over_voltage_counter = jsn.at("AverageRMSOverVoltageCounter").get(); + + new_updated_state.average_rms_over_voltage_counter = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounter") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter = jsn.at("AverageRMSUnderVoltageCounter").get(); ++ new_state.average_rms_under_voltage_counter = jsn.at("AverageRMSUnderVoltageCounter").get(); + + new_updated_state.average_rms_under_voltage_counter = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriod") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period = jsn.at("RMSExtremeOverVoltagePeriod").get(); ++ new_state.rms_extreme_over_voltage_period = jsn.at("RMSExtremeOverVoltagePeriod").get(); + + new_updated_state.rms_extreme_over_voltage_period = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriod") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period = jsn.at("RMSExtremeUnderVoltagePeriod").get(); ++ new_state.rms_extreme_under_voltage_period = jsn.at("RMSExtremeUnderVoltagePeriod").get(); + + new_updated_state.rms_extreme_under_voltage_period = true; + } + + if (jsn.find("RMSVoltageSagPeriod") != jsn.end()) { + +- new_state.rms_voltage_sag_period = jsn.at("RMSVoltageSagPeriod").get(); ++ new_state.rms_voltage_sag_period = jsn.at("RMSVoltageSagPeriod").get(); + + new_updated_state.rms_voltage_sag_period = true; + } + + if (jsn.find("RMSVoltageSwellPeriod") != jsn.end()) { + +- new_state.rms_voltage_swell_period = jsn.at("RMSVoltageSwellPeriod").get(); ++ new_state.rms_voltage_swell_period = jsn.at("RMSVoltageSwellPeriod").get(); + + new_updated_state.rms_voltage_swell_period = true; + } +@@ -13185,98 +13185,98 @@ void uic_mqtt_dotdot_parse_electrical_measurement_write_attributes( + + if (jsn.find("AverageRMSVoltageMeasurementPeriodPhB") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period_phb = jsn.at("AverageRMSVoltageMeasurementPeriodPhB").get(); ++ new_state.average_rms_voltage_measurement_period_phb = jsn.at("AverageRMSVoltageMeasurementPeriodPhB").get(); + + new_updated_state.average_rms_voltage_measurement_period_phb = true; + } + + if (jsn.find("AverageRMSOverVoltageCounterPhB") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter_phb = jsn.at("AverageRMSOverVoltageCounterPhB").get(); ++ new_state.average_rms_over_voltage_counter_phb = jsn.at("AverageRMSOverVoltageCounterPhB").get(); + + new_updated_state.average_rms_over_voltage_counter_phb = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounterPhB") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter_phb = jsn.at("AverageRMSUnderVoltageCounterPhB").get(); ++ new_state.average_rms_under_voltage_counter_phb = jsn.at("AverageRMSUnderVoltageCounterPhB").get(); + + new_updated_state.average_rms_under_voltage_counter_phb = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriodPhB") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period_phb = jsn.at("RMSExtremeOverVoltagePeriodPhB").get(); ++ new_state.rms_extreme_over_voltage_period_phb = jsn.at("RMSExtremeOverVoltagePeriodPhB").get(); + + new_updated_state.rms_extreme_over_voltage_period_phb = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriodPhB") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period_phb = jsn.at("RMSExtremeUnderVoltagePeriodPhB").get(); ++ new_state.rms_extreme_under_voltage_period_phb = jsn.at("RMSExtremeUnderVoltagePeriodPhB").get(); + + new_updated_state.rms_extreme_under_voltage_period_phb = true; + } + + if (jsn.find("RMSVoltageSagPeriodPhB") != jsn.end()) { + +- new_state.rms_voltage_sag_period_phb = jsn.at("RMSVoltageSagPeriodPhB").get(); ++ new_state.rms_voltage_sag_period_phb = jsn.at("RMSVoltageSagPeriodPhB").get(); + + new_updated_state.rms_voltage_sag_period_phb = true; + } + + if (jsn.find("RMSVoltageSwellPeriodPhB") != jsn.end()) { + +- new_state.rms_voltage_swell_period_phb = jsn.at("RMSVoltageSwellPeriodPhB").get(); ++ new_state.rms_voltage_swell_period_phb = jsn.at("RMSVoltageSwellPeriodPhB").get(); + + new_updated_state.rms_voltage_swell_period_phb = true; + } + + if (jsn.find("AverageRMSVoltageMeasurementPeriodPhC") != jsn.end()) { + +- new_state.average_rms_voltage_measurement_period_phc = jsn.at("AverageRMSVoltageMeasurementPeriodPhC").get(); ++ new_state.average_rms_voltage_measurement_period_phc = jsn.at("AverageRMSVoltageMeasurementPeriodPhC").get(); + + new_updated_state.average_rms_voltage_measurement_period_phc = true; + } + + if (jsn.find("AverageRMSOverVoltageCounterPhC") != jsn.end()) { + +- new_state.average_rms_over_voltage_counter_phc = jsn.at("AverageRMSOverVoltageCounterPhC").get(); ++ new_state.average_rms_over_voltage_counter_phc = jsn.at("AverageRMSOverVoltageCounterPhC").get(); + + new_updated_state.average_rms_over_voltage_counter_phc = true; + } + + if (jsn.find("AverageRMSUnderVoltageCounterPhC") != jsn.end()) { + +- new_state.average_rms_under_voltage_counter_phc = jsn.at("AverageRMSUnderVoltageCounterPhC").get(); ++ new_state.average_rms_under_voltage_counter_phc = jsn.at("AverageRMSUnderVoltageCounterPhC").get(); + + new_updated_state.average_rms_under_voltage_counter_phc = true; + } + + if (jsn.find("RMSExtremeOverVoltagePeriodPhC") != jsn.end()) { + +- new_state.rms_extreme_over_voltage_period_phc = jsn.at("RMSExtremeOverVoltagePeriodPhC").get(); ++ new_state.rms_extreme_over_voltage_period_phc = jsn.at("RMSExtremeOverVoltagePeriodPhC").get(); + + new_updated_state.rms_extreme_over_voltage_period_phc = true; + } + + if (jsn.find("RMSExtremeUnderVoltagePeriodPhC") != jsn.end()) { + +- new_state.rms_extreme_under_voltage_period_phc = jsn.at("RMSExtremeUnderVoltagePeriodPhC").get(); ++ new_state.rms_extreme_under_voltage_period_phc = jsn.at("RMSExtremeUnderVoltagePeriodPhC").get(); + + new_updated_state.rms_extreme_under_voltage_period_phc = true; + } + + if (jsn.find("RMSVoltageSagPeriodPhC") != jsn.end()) { + +- new_state.rms_voltage_sag_period_phc = jsn.at("RMSVoltageSagPeriodPhC").get(); ++ new_state.rms_voltage_sag_period_phc = jsn.at("RMSVoltageSagPeriodPhC").get(); + + new_updated_state.rms_voltage_sag_period_phc = true; + } + + if (jsn.find("RMSVoltageSwellPeriodPhC") != jsn.end()) { + +- new_state.rms_voltage_swell_period_phc = jsn.at("RMSVoltageSwellPeriodPhC").get(); ++ new_state.rms_voltage_swell_period_phc = jsn.at("RMSVoltageSwellPeriodPhC").get(); + + new_updated_state.rms_voltage_swell_period_phc = true; + } +@@ -13419,13 +13419,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + bool &transmission_successful, + +- int16_t &transmission_time_ms, ++ uint16_t &transmission_time_ms, + + int8_t &tx_powerd_bm, + +- int8_t &tx_channel, ++ uint8_t &tx_channel, + +- int8_t &routing_attempts, ++ uint8_t &routing_attempts, + + bool &route_changed, + +@@ -13439,7 +13439,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + int8_t &ackrssi, + +- int8_t &ack_channel, ++ uint8_t &ack_channel, + + std::string &last_route_failed_link_functionalunid, + +@@ -13482,7 +13482,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- transmission_time_ms = jsn.at("TransmissionTimeMs").get< int16_t >(); ++ transmission_time_ms = jsn.at("TransmissionTimeMs").get< uint16_t >(); + if (jsn.at("TxPowerdBm").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13494,13 +13494,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- tx_channel = jsn.at("TxChannel").get< int8_t >(); ++ tx_channel = jsn.at("TxChannel").get< uint8_t >(); + if (jsn.at("RoutingAttempts").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- routing_attempts = jsn.at("RoutingAttempts").get< int8_t >(); ++ routing_attempts = jsn.at("RoutingAttempts").get< uint8_t >(); + if (jsn.at("RouteChanged").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13543,7 +13543,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + return; + } + +- ack_channel = jsn.at("AckChannel").get< int8_t >(); ++ ack_channel = jsn.at("AckChannel").get< uint8_t >(); + if (jsn.at("LastRouteFailedLinkFunctionalUNID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -13774,7 +13774,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + + std::string &destination_unid, + +- int8_t &destination_ep ++ uint8_t &destination_ep + + ) { + +@@ -13795,7 +13795,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + return; + } + +- destination_ep = jsn.at("DestinationEp").get< int8_t >(); ++ destination_ep = jsn.at("DestinationEp").get< uint8_t >(); + } + + +@@ -13836,7 +13836,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + + std::string &destination_unid, + +- int8_t &destination_ep ++ uint8_t &destination_ep + + ) { + +@@ -13857,7 +13857,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + return; + } + +- destination_ep = jsn.at("DestinationEp").get< int8_t >(); ++ destination_ep = jsn.at("DestinationEp").get< uint8_t >(); + } + + +@@ -13967,7 +13967,7 @@ void uic_mqtt_dotdot_parse_system_metrics_write_attributes( + + if (jsn.find("ReportingIntervalSeconds") != jsn.end()) { + +- new_state.reporting_interval_seconds = jsn.at("ReportingIntervalSeconds").get(); ++ new_state.reporting_interval_seconds = jsn.at("ReportingIntervalSeconds").get(); + + new_updated_state.reporting_interval_seconds = true; + } +@@ -14102,14 +14102,14 @@ void uic_mqtt_dotdot_parse_application_monitoring_write_attributes( + + if (jsn.find("MQTTStatisticsReportingIntervalSeconds") != jsn.end()) { + +- new_state.mqtt_statistics_reporting_interval_seconds = jsn.at("MQTTStatisticsReportingIntervalSeconds").get(); ++ new_state.mqtt_statistics_reporting_interval_seconds = jsn.at("MQTTStatisticsReportingIntervalSeconds").get(); + + new_updated_state.mqtt_statistics_reporting_interval_seconds = true; + } + + if (jsn.find("ApplicationStatisticsReportingIntervalSeconds") != jsn.end()) { + +- new_state.application_statistics_reporting_interval_seconds = jsn.at("ApplicationStatisticsReportingIntervalSeconds").get(); ++ new_state.application_statistics_reporting_interval_seconds = jsn.at("ApplicationStatisticsReportingIntervalSeconds").get(); + + new_updated_state.application_statistics_reporting_interval_seconds = true; + } +@@ -14173,7 +14173,7 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_com + + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + nlohmann::json &jsn, +- int16_t ¶meter_id ++ uint16_t ¶meter_id + + ) { + +@@ -14182,7 +14182,7 @@ void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + return; + } + +- parameter_id = jsn.at("ParameterId").get< int16_t >(); ++ parameter_id = jsn.at("ParameterId").get< uint16_t >(); + } + + +@@ -14234,7 +14234,7 @@ std::string get_json_payload_for_configuration_parameters_set_parameter_command( + + void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + nlohmann::json &jsn, +- int16_t ¶meter_id, ++ uint16_t ¶meter_id, + + int64_t &value + +@@ -14245,7 +14245,7 @@ void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + return; + } + +- parameter_id = jsn.at("ParameterId").get< int16_t >(); ++ parameter_id = jsn.at("ParameterId").get< uint16_t >(); + if (jsn.at("Value").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14284,9 +14284,9 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_ran + + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + nlohmann::json &jsn, +- int16_t &first_parameter_id, ++ uint16_t &first_parameter_id, + +- int16_t &last_parameter_id ++ uint16_t &last_parameter_id + + ) { + +@@ -14295,13 +14295,13 @@ void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + return; + } + +- first_parameter_id = jsn.at("FirstParameterId").get< int16_t >(); ++ first_parameter_id = jsn.at("FirstParameterId").get< uint16_t >(); + if (jsn.at("LastParameterId").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- last_parameter_id = jsn.at("LastParameterId").get< int16_t >(); ++ last_parameter_id = jsn.at("LastParameterId").get< uint16_t >(); + } + + +@@ -14403,7 +14403,7 @@ std::string get_json_payload_for_user_credential_add_user_command( + + void uic_mqtt_dotdot_parse_user_credential_add_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + UserTypeEnum &user_type, + +@@ -14413,7 +14413,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_user( + + std::string &user_name, + +- int16_t &expiring_timeout_minutes, ++ uint16_t &expiring_timeout_minutes, + + UserNameEncodingType &user_name_encoding + +@@ -14442,7 +14442,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14470,7 +14470,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_user( + return; + } + +- expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< int16_t >(); ++ expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< uint16_t >(); + if (jsn.at("UserNameEncoding").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14561,7 +14561,7 @@ std::string get_json_payload_for_user_credential_modify_user_command( + + void uic_mqtt_dotdot_parse_user_credential_modify_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + UserTypeEnum &user_type, + +@@ -14571,7 +14571,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_user( + + std::string &user_name, + +- int16_t &expiring_timeout_minutes, ++ uint16_t &expiring_timeout_minutes, + + UserNameEncodingType &user_name_encoding + +@@ -14600,7 +14600,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("UserType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14628,7 +14628,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_user( + return; + } + +- expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< int16_t >(); ++ expiring_timeout_minutes = jsn.at("ExpiringTimeoutMinutes").get< uint16_t >(); + if (jsn.at("UserNameEncoding").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14662,7 +14662,7 @@ std::string get_json_payload_for_user_credential_delete_user_command( + + void uic_mqtt_dotdot_parse_user_credential_delete_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ) { + +@@ -14671,7 +14671,7 @@ void uic_mqtt_dotdot_parse_user_credential_delete_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + } + + +@@ -14723,11 +14723,11 @@ std::string get_json_payload_for_user_credential_add_credential_command( + + void uic_mqtt_dotdot_parse_user_credential_add_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + + std::string &credential_data + +@@ -14744,7 +14744,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_credential( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14755,7 +14755,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_credential( + return; + } + +- credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ credential_slot = jsn.at("CredentialSlot").get< uint16_t >(); + if (jsn.at("CredentialData").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14813,11 +14813,11 @@ std::string get_json_payload_for_user_credential_modify_credential_command( + + void uic_mqtt_dotdot_parse_user_credential_modify_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + + std::string &credential_data + +@@ -14834,7 +14834,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_credential( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14845,7 +14845,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_credential( + return; + } + +- credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ credential_slot = jsn.at("CredentialSlot").get< uint16_t >(); + if (jsn.at("CredentialData").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14899,11 +14899,11 @@ std::string get_json_payload_for_user_credential_delete_credential_command( + + void uic_mqtt_dotdot_parse_user_credential_delete_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot ++ uint16_t &credential_slot + + ) { + +@@ -14918,7 +14918,7 @@ void uic_mqtt_dotdot_parse_user_credential_delete_credential( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -14929,7 +14929,7 @@ void uic_mqtt_dotdot_parse_user_credential_delete_credential( + return; + } + +- credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ credential_slot = jsn.at("CredentialSlot").get< uint16_t >(); + } + + +@@ -15050,7 +15050,7 @@ std::string get_json_payload_for_user_credential_delete_all_credentials_for_user + + void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ) { + +@@ -15059,7 +15059,7 @@ void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + } + + +@@ -15103,7 +15103,7 @@ std::string get_json_payload_for_user_credential_delete_all_credentials_for_user + + void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type + +@@ -15120,7 +15120,7 @@ void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_ty + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -15177,13 +15177,13 @@ std::string get_json_payload_for_user_credential_credential_learn_start_add_comm + + void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + +- int8_t &credential_learn_timeout ++ uint8_t &credential_learn_timeout + + ) { + +@@ -15198,7 +15198,7 @@ void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -15209,13 +15209,13 @@ void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + return; + } + +- credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ credential_slot = jsn.at("CredentialSlot").get< uint16_t >(); + if (jsn.at("CredentialLearnTimeout").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< int8_t >(); ++ credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< uint8_t >(); + } + + +@@ -15267,13 +15267,13 @@ std::string get_json_payload_for_user_credential_credential_learn_start_modify_c + + void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + +- int8_t &credential_learn_timeout ++ uint8_t &credential_learn_timeout + + ) { + +@@ -15288,7 +15288,7 @@ void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + if (jsn.at("CredentialType").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +@@ -15299,13 +15299,13 @@ void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( + return; + } + +- credential_slot = jsn.at("CredentialSlot").get< int16_t >(); ++ credential_slot = jsn.at("CredentialSlot").get< uint16_t >(); + if (jsn.at("CredentialLearnTimeout").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< int8_t >(); ++ credential_learn_timeout = jsn.at("CredentialLearnTimeout").get< uint8_t >(); + } + + +@@ -15382,13 +15382,13 @@ void uic_mqtt_dotdot_parse_user_credential_credential_association( + nlohmann::json &jsn, + CredType &credential_type, + +- int16_t &source_user_uniqueid, ++ uint16_t &source_user_uniqueid, + +- int16_t &source_credential_slot, ++ uint16_t &source_credential_slot, + +- int16_t &destination_user_uniqueid, ++ uint16_t &destination_user_uniqueid, + +- int16_t &destination_credential_slot ++ uint16_t &destination_credential_slot + + ) { + +@@ -15408,25 +15408,25 @@ void uic_mqtt_dotdot_parse_user_credential_credential_association( + return; + } + +- source_user_uniqueid = jsn.at("SourceUserUniqueID").get< int16_t >(); ++ source_user_uniqueid = jsn.at("SourceUserUniqueID").get< uint16_t >(); + if (jsn.at("SourceCredentialSlot").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- source_credential_slot = jsn.at("SourceCredentialSlot").get< int16_t >(); ++ source_credential_slot = jsn.at("SourceCredentialSlot").get< uint16_t >(); + if (jsn.at("DestinationUserUniqueID").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- destination_user_uniqueid = jsn.at("DestinationUserUniqueID").get< int16_t >(); ++ destination_user_uniqueid = jsn.at("DestinationUserUniqueID").get< uint16_t >(); + if (jsn.at("DestinationCredentialSlot").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- destination_credential_slot = jsn.at("DestinationCredentialSlot").get< int16_t >(); ++ destination_credential_slot = jsn.at("DestinationCredentialSlot").get< uint16_t >(); + } + + +@@ -15455,7 +15455,7 @@ std::string get_json_payload_for_user_credential_get_user_checksum_command( + + void uic_mqtt_dotdot_parse_user_credential_get_user_checksum( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ) { + +@@ -15464,7 +15464,7 @@ void uic_mqtt_dotdot_parse_user_credential_get_user_checksum( + return; + } + +- user_uniqueid = jsn.at("UserUniqueID").get< int16_t >(); ++ user_uniqueid = jsn.at("UserUniqueID").get< uint16_t >(); + } + + +@@ -15904,9 +15904,9 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + nlohmann::json &jsn, + SetpointType &type, + +- int8_t &precision, ++ uint8_t &precision, + +- int8_t &scale, ++ uint8_t &scale, + + int32_t &value + +@@ -15928,13 +15928,13 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + return; + } + +- precision = jsn.at("Precision").get< int8_t >(); ++ precision = jsn.at("Precision").get< uint8_t >(); + if (jsn.at("Scale").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; + } + +- scale = jsn.at("Scale").get< int8_t >(); ++ scale = jsn.at("Scale").get< uint8_t >(); + if (jsn.at("Value").is_null()) { + sl_log_debug(LOG_TAG, "Ignoring JSON Null object"); + return; +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp +index 762addab76..ede2d6189e 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_command_helpers.hpp +@@ -102,7 +102,7 @@ std::string get_json_payload_for_identify_identify_command( + */ + void uic_mqtt_dotdot_parse_identify_identify( + nlohmann::json &jsn, +- int16_t &identify_time ++ uint16_t &identify_time + + ); + +@@ -130,7 +130,7 @@ std::string get_json_payload_for_identify_identify_query_response_command( + */ + void uic_mqtt_dotdot_parse_identify_identify_query_response( + nlohmann::json &jsn, +- int16_t &timeout ++ uint16_t &timeout + + ); + +@@ -213,7 +213,7 @@ std::string get_json_payload_for_groups_add_group_command( + */ + void uic_mqtt_dotdot_parse_groups_add_group( + nlohmann::json &jsn, +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -245,7 +245,7 @@ void uic_mqtt_dotdot_parse_groups_add_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id ++ uint16_t &group_id + + ); + +@@ -273,7 +273,7 @@ std::string get_json_payload_for_groups_view_group_command( + */ + void uic_mqtt_dotdot_parse_groups_view_group( + nlohmann::json &jsn, +- int16_t &group_id ++ uint16_t &group_id + + ); + +@@ -303,7 +303,7 @@ void uic_mqtt_dotdot_parse_groups_view_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -333,7 +333,7 @@ std::string get_json_payload_for_groups_get_group_membership_command( + */ + void uic_mqtt_dotdot_parse_groups_get_group_membership( + nlohmann::json &jsn, +- std::vector &group_list ++ std::vector &group_list + + ); + +@@ -361,9 +361,9 @@ std::string get_json_payload_for_groups_get_group_membership_response_command( + */ + void uic_mqtt_dotdot_parse_groups_get_group_membership_response( + nlohmann::json &jsn, +- int8_t &capacity, ++ uint8_t &capacity, + +- std::vector &group_list ++ std::vector &group_list + + ); + +@@ -391,7 +391,7 @@ std::string get_json_payload_for_groups_remove_group_command( + */ + void uic_mqtt_dotdot_parse_groups_remove_group( + nlohmann::json &jsn, +- int16_t &group_id ++ uint16_t &group_id + + ); + +@@ -421,7 +421,7 @@ void uic_mqtt_dotdot_parse_groups_remove_group_response( + nlohmann::json &jsn, + uint8_t &status, + +- int16_t &group_id ++ uint16_t &group_id + + ); + +@@ -462,7 +462,7 @@ std::string get_json_payload_for_groups_add_group_if_identifying_command( + */ + void uic_mqtt_dotdot_parse_groups_add_group_if_identifying( + nlohmann::json &jsn, +- int16_t &group_id, ++ uint16_t &group_id, + + std::string &group_name + +@@ -504,17 +504,17 @@ std::string get_json_payload_for_scenes_add_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_add_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + + std::vector &extension_field_sets, + +- int8_t &transition_time100ms ++ uint8_t &transition_time100ms + + ); + +@@ -544,9 +544,9 @@ void uic_mqtt_dotdot_parse_scenes_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -574,9 +574,9 @@ std::string get_json_payload_for_scenes_view_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_view_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -606,11 +606,11 @@ void uic_mqtt_dotdot_parse_scenes_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -642,9 +642,9 @@ std::string get_json_payload_for_scenes_remove_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_remove_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -674,9 +674,9 @@ void uic_mqtt_dotdot_parse_scenes_remove_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -704,7 +704,7 @@ std::string get_json_payload_for_scenes_remove_all_scenes_command( + */ + void uic_mqtt_dotdot_parse_scenes_remove_all_scenes( + nlohmann::json &jsn, +- uint8_t * &groupid ++ uint16_t &groupid + + ); + +@@ -734,7 +734,7 @@ void uic_mqtt_dotdot_parse_scenes_remove_all_scenes_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid ++ uint16_t &groupid + + ); + +@@ -762,9 +762,9 @@ std::string get_json_payload_for_scenes_store_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_store_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -794,9 +794,9 @@ void uic_mqtt_dotdot_parse_scenes_store_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -824,11 +824,11 @@ std::string get_json_payload_for_scenes_recall_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_recall_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time ++ uint16_t &transition_time + + ); + +@@ -856,7 +856,7 @@ std::string get_json_payload_for_scenes_get_scene_membership_command( + */ + void uic_mqtt_dotdot_parse_scenes_get_scene_membership( + nlohmann::json &jsn, +- uint8_t * &groupid ++ uint16_t &groupid + + ); + +@@ -886,11 +886,11 @@ void uic_mqtt_dotdot_parse_scenes_get_scene_membership_response( + nlohmann::json &jsn, + zclStatus &status, + +- int8_t &capacity, ++ uint8_t &capacity, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- std::vector &scene_list ++ std::vector &scene_list + + ); + +@@ -918,11 +918,11 @@ std::string get_json_payload_for_scenes_enhanced_add_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -956,9 +956,9 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_add_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -986,9 +986,9 @@ std::string get_json_payload_for_scenes_enhanced_view_scene_command( + */ + void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene( + nlohmann::json &jsn, +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid ++ uint8_t &sceneid + + ); + +@@ -1018,11 +1018,11 @@ void uic_mqtt_dotdot_parse_scenes_enhanced_view_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &groupid, ++ uint16_t &groupid, + +- int8_t &sceneid, ++ uint8_t &sceneid, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + std::string &scene_name, + +@@ -1056,13 +1056,13 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene( + nlohmann::json &jsn, + uint8_t &mode, + +- uint8_t * &group_identifier_from, ++ uint16_t &group_identifier_from, + +- int8_t &scene_identifier_from, ++ uint8_t &scene_identifier_from, + +- uint8_t * &group_identifier_to, ++ uint16_t &group_identifier_to, + +- int8_t &scene_identifier_to ++ uint8_t &scene_identifier_to + + ); + +@@ -1092,9 +1092,9 @@ void uic_mqtt_dotdot_parse_scenes_copy_scene_response( + nlohmann::json &jsn, + zclStatus &status, + +- uint8_t * &group_identifier_from, ++ uint16_t &group_identifier_from, + +- int8_t &scene_identifier_from ++ uint8_t &scene_identifier_from + + ); + +@@ -1175,7 +1175,7 @@ void uic_mqtt_dotdot_parse_on_off_off_with_effect( + nlohmann::json &jsn, + OffWithEffectEffectIdentifier &effect_identifier, + +- int8_t &effect_variant ++ uint8_t &effect_variant + + ); + +@@ -1218,9 +1218,9 @@ void uic_mqtt_dotdot_parse_on_off_on_with_timed_off( + nlohmann::json &jsn, + uint8_t &on_off_control, + +- int16_t &on_time, ++ uint16_t &on_time, + +- int16_t &off_wait_time ++ uint16_t &off_wait_time + + ); + +@@ -1260,9 +1260,9 @@ std::string get_json_payload_for_level_move_to_level_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_level( + nlohmann::json &jsn, +- int8_t &level, ++ uint8_t &level, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -1296,7 +1296,7 @@ void uic_mqtt_dotdot_parse_level_move( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -1330,9 +1330,9 @@ void uic_mqtt_dotdot_parse_level_step( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -1394,9 +1394,9 @@ std::string get_json_payload_for_level_move_to_level_with_on_off_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_level_with_on_off( + nlohmann::json &jsn, +- int8_t &level, ++ uint8_t &level, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -1430,7 +1430,7 @@ void uic_mqtt_dotdot_parse_level_move_with_on_off( + nlohmann::json &jsn, + MoveStepMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -1464,9 +1464,9 @@ void uic_mqtt_dotdot_parse_level_step_with_on_off( + nlohmann::json &jsn, + MoveStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -1528,7 +1528,7 @@ std::string get_json_payload_for_level_move_to_closest_frequency_command( + */ + void uic_mqtt_dotdot_parse_level_move_to_closest_frequency( + nlohmann::json &jsn, +- int16_t &frequency ++ uint16_t &frequency + + ); + +@@ -1570,7 +1570,7 @@ void uic_mqtt_dotdot_parse_alarms_reset_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint8_t &cluster_identifier ++ uint16_t &cluster_identifier + + ); + +@@ -1600,7 +1600,7 @@ void uic_mqtt_dotdot_parse_alarms_alarm( + nlohmann::json &jsn, + uint8_t &alarm_code, + +- uint8_t &cluster_identifier ++ uint16_t &cluster_identifier + + ); + +@@ -1645,9 +1645,9 @@ void uic_mqtt_dotdot_parse_alarms_get_alarm_response( + + uint8_t &alarm_code, + +- uint8_t &cluster_identifier, ++ uint16_t &cluster_identifier, + +- int32_t &time_stamp ++ uint32_t &time_stamp + + ); + +@@ -1740,7 +1740,7 @@ void uic_mqtt_dotdot_parse_poll_control_check_in_response( + nlohmann::json &jsn, + bool &start_fast_polling, + +- int16_t &fast_poll_timeout ++ uint16_t &fast_poll_timeout + + ); + +@@ -1781,7 +1781,7 @@ std::string get_json_payload_for_poll_control_set_long_poll_interval_command( + */ + void uic_mqtt_dotdot_parse_poll_control_set_long_poll_interval( + nlohmann::json &jsn, +- int32_t &new_long_poll_interval ++ uint32_t &new_long_poll_interval + + ); + +@@ -1809,7 +1809,7 @@ std::string get_json_payload_for_poll_control_set_short_poll_interval_command( + */ + void uic_mqtt_dotdot_parse_poll_control_set_short_poll_interval( + nlohmann::json &jsn, +- int16_t &new_short_poll_interval ++ uint16_t &new_short_poll_interval + + ); + +@@ -2029,7 +2029,7 @@ std::string get_json_payload_for_door_lock_unlock_with_timeout_command( + */ + void uic_mqtt_dotdot_parse_door_lock_unlock_with_timeout( + nlohmann::json &jsn, +- int16_t &timeout_in_seconds, ++ uint16_t &timeout_in_seconds, + + std::string &pin_or_rfid_code + +@@ -2087,7 +2087,7 @@ std::string get_json_payload_for_door_lock_get_log_record_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_log_record( + nlohmann::json &jsn, +- int16_t &log_index ++ uint16_t &log_index + + ); + +@@ -2115,17 +2115,17 @@ std::string get_json_payload_for_door_lock_get_log_record_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_log_record_response( + nlohmann::json &jsn, +- int16_t &log_entryid, ++ uint16_t &log_entryid, + +- int32_t ×tamp, ++ uint32_t ×tamp, + + GetLogRecordResponseEventType &event_type, + + DrlkOperEventSource &source_operation_event, + +- int8_t &event_id_or_alarm_code, ++ uint8_t &event_id_or_alarm_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin + +@@ -2155,7 +2155,7 @@ std::string get_json_payload_for_door_lock_set_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status, + +@@ -2217,7 +2217,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2245,7 +2245,7 @@ std::string get_json_payload_for_door_lock_get_pin_code_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_pin_code_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status, + +@@ -2279,7 +2279,7 @@ std::string get_json_payload_for_door_lock_clear_pin_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_pin_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2376,7 +2376,7 @@ std::string get_json_payload_for_door_lock_set_user_status_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_user_status( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status + +@@ -2434,7 +2434,7 @@ std::string get_json_payload_for_door_lock_get_user_status_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_status( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2462,7 +2462,7 @@ std::string get_json_payload_for_door_lock_get_user_status_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_status_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status + +@@ -2492,19 +2492,19 @@ std::string get_json_payload_for_door_lock_set_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid, ++ uint16_t &userid, + + uint8_t &days_mask, + +- int8_t &start_hour, ++ uint8_t &start_hour, + +- int8_t &start_minute, ++ uint8_t &start_minute, + +- int8_t &end_hour, ++ uint8_t &end_hour, + +- int8_t &end_minute ++ uint8_t &end_minute + + ); + +@@ -2560,9 +2560,9 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2590,21 +2590,21 @@ std::string get_json_payload_for_door_lock_get_weekday_schedule_response_command + */ + void uic_mqtt_dotdot_parse_door_lock_get_weekday_schedule_response( + nlohmann::json &jsn, +- int8_t &scheduleid, ++ uint8_t &scheduleid, + +- int16_t &userid, ++ uint16_t &userid, + + zclStatus &status, + + uint8_t &days_mask, + +- int8_t &start_hour, ++ uint8_t &start_hour, + +- int8_t &start_minute, ++ uint8_t &start_minute, + +- int8_t &end_hour, ++ uint8_t &end_hour, + +- int8_t &end_minute ++ uint8_t &end_minute + + ); + +@@ -2632,9 +2632,9 @@ std::string get_json_payload_for_door_lock_clear_weekday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_weekday_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2690,13 +2690,13 @@ std::string get_json_payload_for_door_lock_set_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid, ++ uint16_t &userid, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time ++ uint32_t &local_end_time + + ); + +@@ -2752,9 +2752,9 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2782,15 +2782,15 @@ std::string get_json_payload_for_door_lock_get_year_day_schedule_response_comman + */ + void uic_mqtt_dotdot_parse_door_lock_get_year_day_schedule_response( + nlohmann::json &jsn, +- int8_t &scheduleid, ++ uint8_t &scheduleid, + +- int16_t &userid, ++ uint16_t &userid, + + zclStatus &status, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time ++ uint32_t &local_end_time + + ); + +@@ -2818,9 +2818,9 @@ std::string get_json_payload_for_door_lock_clear_year_day_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_year_day_schedule( + nlohmann::json &jsn, +- uint8_t * &scheduleid, ++ uint8_t &scheduleid, + +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -2876,11 +2876,11 @@ std::string get_json_payload_for_door_lock_set_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid, ++ uint8_t &holiday_scheduleid, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time, ++ uint32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -2938,7 +2938,7 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid ++ uint8_t &holiday_scheduleid + + ); + +@@ -2966,13 +2966,13 @@ std::string get_json_payload_for_door_lock_get_holiday_schedule_response_command + */ + void uic_mqtt_dotdot_parse_door_lock_get_holiday_schedule_response( + nlohmann::json &jsn, +- int8_t &holiday_scheduleid, ++ uint8_t &holiday_scheduleid, + + zclStatus &status, + +- int32_t &local_start_time, ++ uint32_t &local_start_time, + +- int32_t &local_end_time, ++ uint32_t &local_end_time, + + DrlkOperMode &operating_mode_during_holiday + +@@ -3002,7 +3002,7 @@ std::string get_json_payload_for_door_lock_clear_holiday_schedule_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_holiday_schedule( + nlohmann::json &jsn, +- uint8_t * &holiday_scheduleid ++ uint8_t &holiday_scheduleid + + ); + +@@ -3058,7 +3058,7 @@ std::string get_json_payload_for_door_lock_set_user_type_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_user_type( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkUserType &user_type + +@@ -3116,7 +3116,7 @@ std::string get_json_payload_for_door_lock_get_user_type_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_type( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -3144,7 +3144,7 @@ std::string get_json_payload_for_door_lock_get_user_type_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user_type_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserType &user_type + +@@ -3174,7 +3174,7 @@ std::string get_json_payload_for_door_lock_set_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_set_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid, ++ uint16_t &userid, + + DrlkSettableUserStatus &user_status, + +@@ -3236,7 +3236,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -3264,7 +3264,7 @@ std::string get_json_payload_for_door_lock_get_rfid_code_response_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_rfid_code_response( + nlohmann::json &jsn, +- int16_t &userid, ++ uint16_t &userid, + + DrlkUserStatus &user_status, + +@@ -3298,7 +3298,7 @@ std::string get_json_payload_for_door_lock_clear_rfid_code_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_rfid_code( + nlohmann::json &jsn, +- uint8_t * &userid ++ uint16_t &userid + + ); + +@@ -3397,11 +3397,11 @@ void uic_mqtt_dotdot_parse_door_lock_set_user( + nlohmann::json &jsn, + DataOperationTypeEnum &operation_type, + +- int16_t &user_index, ++ uint16_t &user_index, + + std::string &user_name, + +- int32_t &user_uniqueid, ++ uint32_t &user_uniqueid, + + DrlkSettableUserStatus &user_status, + +@@ -3435,7 +3435,7 @@ std::string get_json_payload_for_door_lock_get_user_command( + */ + void uic_mqtt_dotdot_parse_door_lock_get_user( + nlohmann::json &jsn, +- int16_t &user_index ++ uint16_t &user_index + + ); + +@@ -3476,7 +3476,7 @@ std::string get_json_payload_for_door_lock_clear_user_command( + */ + void uic_mqtt_dotdot_parse_door_lock_clear_user( + nlohmann::json &jsn, +- int16_t &user_index ++ uint16_t &user_index + + ); + +@@ -3508,11 +3508,11 @@ void uic_mqtt_dotdot_parse_door_lock_operating_event_notification( + + OperatingEventNotificationOperationEventCode &operation_event_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin, + +- int32_t &local_time, ++ uint32_t &local_time, + + std::string &data + +@@ -3546,7 +3546,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + ProgrammingEventNotificationProgramEventCode &program_event_code, + +- int16_t &userid, ++ uint16_t &userid, + + std::string &pin, + +@@ -3554,7 +3554,7 @@ void uic_mqtt_dotdot_parse_door_lock_programming_event_notification( + + DrlkUserStatus &user_status, + +- int32_t &local_time, ++ uint32_t &local_time, + + std::string &data + +@@ -3590,7 +3590,7 @@ void uic_mqtt_dotdot_parse_door_lock_set_credential( + + std::string &credential_data, + +- int16_t &user_index, ++ uint16_t &user_index, + + DrlkSettableUserStatus &user_status, + +@@ -3783,7 +3783,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_value_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_value( + nlohmann::json &jsn, +- int16_t &lift_value ++ uint16_t &lift_value + + ); + +@@ -3811,7 +3811,7 @@ std::string get_json_payload_for_window_covering_go_to_lift_percentage_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_lift_percentage( + nlohmann::json &jsn, +- int8_t &percentage_lift_value ++ uint8_t &percentage_lift_value + + ); + +@@ -3839,7 +3839,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_value_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_value( + nlohmann::json &jsn, +- int16_t &tilt_value ++ uint16_t &tilt_value + + ); + +@@ -3867,7 +3867,7 @@ std::string get_json_payload_for_window_covering_go_to_tilt_percentage_command( + */ + void uic_mqtt_dotdot_parse_window_covering_go_to_tilt_percentage( + nlohmann::json &jsn, +- int8_t &percentage_tilt_value ++ uint8_t &percentage_tilt_value + + ); + +@@ -3907,7 +3907,7 @@ std::string get_json_payload_for_barrier_control_go_to_percent_command( + */ + void uic_mqtt_dotdot_parse_barrier_control_go_to_percent( + nlohmann::json &jsn, +- int8_t &percent_open ++ uint8_t &percent_open + + ); + +@@ -4070,17 +4070,17 @@ std::string get_json_payload_for_thermostat_get_relay_status_log_response_comman + */ + void uic_mqtt_dotdot_parse_thermostat_get_relay_status_log_response( + nlohmann::json &jsn, +- int16_t &time_of_day, ++ uint16_t &time_of_day, + + uint8_t &relay_status, + + int16_t &local_temperature, + +- int8_t &humidity_percentage, ++ uint8_t &humidity_percentage, + + int16_t &set_point, + +- int16_t &unread_entries ++ uint16_t &unread_entries + + ); + +@@ -4212,11 +4212,11 @@ std::string get_json_payload_for_color_control_move_to_hue_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_hue( + nlohmann::json &jsn, +- int8_t &hue, ++ uint8_t &hue, + + CCDirection &direction, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4250,7 +4250,7 @@ void uic_mqtt_dotdot_parse_color_control_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -4284,9 +4284,9 @@ void uic_mqtt_dotdot_parse_color_control_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int8_t &transition_time, ++ uint8_t &transition_time, + + uint8_t &options_mask, + +@@ -4318,9 +4318,9 @@ std::string get_json_payload_for_color_control_move_to_saturation_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_saturation( + nlohmann::json &jsn, +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4354,7 +4354,7 @@ void uic_mqtt_dotdot_parse_color_control_move_saturation( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int8_t &rate, ++ uint8_t &rate, + + uint8_t &options_mask, + +@@ -4388,9 +4388,9 @@ void uic_mqtt_dotdot_parse_color_control_step_saturation( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int8_t &step_size, ++ uint8_t &step_size, + +- int8_t &transition_time, ++ uint8_t &transition_time, + + uint8_t &options_mask, + +@@ -4422,11 +4422,11 @@ std::string get_json_payload_for_color_control_move_to_hue_and_saturation_comman + */ + void uic_mqtt_dotdot_parse_color_control_move_to_hue_and_saturation( + nlohmann::json &jsn, +- int8_t &hue, ++ uint8_t &hue, + +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4458,11 +4458,11 @@ std::string get_json_payload_for_color_control_move_to_color_command( + */ + void uic_mqtt_dotdot_parse_color_control_move_to_color( + nlohmann::json &jsn, +- int16_t &colorx, ++ uint16_t &colorx, + +- int16_t &colory, ++ uint16_t &colory, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4532,7 +4532,7 @@ void uic_mqtt_dotdot_parse_color_control_step_color( + + int16_t &stepy, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4564,9 +4564,9 @@ std::string get_json_payload_for_color_control_move_to_color_temperature_command + */ + void uic_mqtt_dotdot_parse_color_control_move_to_color_temperature( + nlohmann::json &jsn, +- int16_t &color_temperature_mireds, ++ uint16_t &color_temperature_mireds, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4598,11 +4598,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_command( + */ + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue( + nlohmann::json &jsn, +- int16_t &enhanced_hue, ++ uint16_t &enhanced_hue, + + CCDirection &direction, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4636,7 +4636,7 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_move_hue( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int16_t &rate, ++ uint16_t &rate, + + uint8_t &options_mask, + +@@ -4670,9 +4670,9 @@ void uic_mqtt_dotdot_parse_color_control_enhanced_step_hue( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int16_t &step_size, ++ uint16_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4704,11 +4704,11 @@ std::string get_json_payload_for_color_control_enhanced_move_to_hue_and_saturati + */ + void uic_mqtt_dotdot_parse_color_control_enhanced_move_to_hue_and_saturation( + nlohmann::json &jsn, +- int16_t &enhanced_hue, ++ uint16_t &enhanced_hue, + +- int8_t &saturation, ++ uint8_t &saturation, + +- int16_t &transition_time, ++ uint16_t &transition_time, + + uint8_t &options_mask, + +@@ -4746,9 +4746,9 @@ void uic_mqtt_dotdot_parse_color_control_color_loop_set( + + CCColorLoopDirection &direction, + +- int16_t &time, ++ uint16_t &time, + +- int16_t &start_hue, ++ uint16_t &start_hue, + + uint8_t &options_mask, + +@@ -4812,11 +4812,11 @@ void uic_mqtt_dotdot_parse_color_control_move_color_temperature( + nlohmann::json &jsn, + CCMoveMode &move_mode, + +- int16_t &rate, ++ uint16_t &rate, + +- uint8_t * &color_temperature_minimum_mireds, ++ uint16_t &color_temperature_minimum_mireds, + +- uint8_t * &color_temperature_maximum_mireds, ++ uint16_t &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -4850,13 +4850,13 @@ void uic_mqtt_dotdot_parse_color_control_step_color_temperature( + nlohmann::json &jsn, + CCStepMode &step_mode, + +- int16_t &step_size, ++ uint16_t &step_size, + +- int16_t &transition_time, ++ uint16_t &transition_time, + +- uint8_t * &color_temperature_minimum_mireds, ++ uint16_t &color_temperature_minimum_mireds, + +- uint8_t * &color_temperature_maximum_mireds, ++ uint16_t &color_temperature_maximum_mireds, + + uint8_t &options_mask, + +@@ -5082,7 +5082,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_response( + nlohmann::json &jsn, + ZoneEnrollResponseEnrollResponseCode &enroll_response_code, + +- int8_t &zoneid ++ uint8_t &zoneid + + ); + +@@ -5114,9 +5114,9 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_status_change_notification( + + uint8_t &extended_status, + +- int8_t &zoneid, ++ uint8_t &zoneid, + +- int16_t &delay ++ uint16_t &delay + + ); + +@@ -5159,7 +5159,7 @@ void uic_mqtt_dotdot_parse_ias_zone_zone_enroll_request( + nlohmann::json &jsn, + IasZoneType &zone_type, + +- int16_t &manufacturer_code ++ uint16_t &manufacturer_code + + ); + +@@ -5187,9 +5187,9 @@ std::string get_json_payload_for_ias_zone_initiate_test_mode_command( + */ + void uic_mqtt_dotdot_parse_ias_zone_initiate_test_mode( + nlohmann::json &jsn, +- int8_t &test_mode_duration, ++ uint8_t &test_mode_duration, + +- int8_t ¤t_zone_sensitivity_level ++ uint8_t ¤t_zone_sensitivity_level + + ); + +@@ -5231,9 +5231,9 @@ void uic_mqtt_dotdot_parse_iaswd_start_warning( + nlohmann::json &jsn, + uint8_t &siren_configuration, + +- int16_t &warning_duration, ++ uint16_t &warning_duration, + +- int8_t &strobe_duty_cycle, ++ uint8_t &strobe_duty_cycle, + + IaswdLevel &strobe_level + +@@ -5315,13 +5315,13 @@ std::string get_json_payload_for_electrical_measurement_get_profile_info_respons + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_profile_info_response( + nlohmann::json &jsn, +- int8_t &profile_count, ++ uint8_t &profile_count, + + ProfileIntervalPeriod &profile_interval_period, + +- int8_t &max_number_of_intervals, ++ uint8_t &max_number_of_intervals, + +- std::vector &list_of_attributes ++ std::vector &list_of_attributes + + ); + +@@ -5362,17 +5362,17 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile_response( + nlohmann::json &jsn, +- uint8_t &start_time, ++ uint32_t &start_time, + + GetMeasurementProfileResponseStatus &status, + + ProfileIntervalPeriod &profile_interval_period, + +- int8_t &number_of_intervals_delivered, ++ uint8_t &number_of_intervals_delivered, + +- uint8_t &attribute_id, ++ uint16_t &attribute_id, + +- std::vector &intervals ++ std::vector &intervals + + ); + +@@ -5400,11 +5400,11 @@ std::string get_json_payload_for_electrical_measurement_get_measurement_profile_ + */ + void uic_mqtt_dotdot_parse_electrical_measurement_get_measurement_profile( + nlohmann::json &jsn, +- uint8_t &attributeid, ++ uint16_t &attributeid, + +- uint8_t &start_time, ++ uint32_t &start_time, + +- int8_t &number_of_intervals ++ uint8_t &number_of_intervals + + ); + +@@ -5462,13 +5462,13 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + bool &transmission_successful, + +- int16_t &transmission_time_ms, ++ uint16_t &transmission_time_ms, + + int8_t &tx_powerd_bm, + +- int8_t &tx_channel, ++ uint8_t &tx_channel, + +- int8_t &routing_attempts, ++ uint8_t &routing_attempts, + + bool &route_changed, + +@@ -5482,7 +5482,7 @@ void uic_mqtt_dotdot_parse_protocol_controller_rf_telemetry_tx_report( + + int8_t &ackrssi, + +- int8_t &ack_channel, ++ uint8_t &ack_channel, + + std::string &last_route_failed_link_functionalunid, + +@@ -5626,7 +5626,7 @@ void uic_mqtt_dotdot_parse_binding_bind( + + std::string &destination_unid, + +- int8_t &destination_ep ++ uint8_t &destination_ep + + ); + +@@ -5658,7 +5658,7 @@ void uic_mqtt_dotdot_parse_binding_unbind( + + std::string &destination_unid, + +- int8_t &destination_ep ++ uint8_t &destination_ep + + ); + +@@ -5824,7 +5824,7 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_com + */ + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter( + nlohmann::json &jsn, +- int16_t ¶meter_id ++ uint16_t ¶meter_id + + ); + +@@ -5865,7 +5865,7 @@ std::string get_json_payload_for_configuration_parameters_set_parameter_command( + */ + void uic_mqtt_dotdot_parse_configuration_parameters_set_parameter( + nlohmann::json &jsn, +- int16_t ¶meter_id, ++ uint16_t ¶meter_id, + + int64_t &value + +@@ -5895,9 +5895,9 @@ std::string get_json_payload_for_configuration_parameters_discover_parameter_ran + */ + void uic_mqtt_dotdot_parse_configuration_parameters_discover_parameter_range( + nlohmann::json &jsn, +- int16_t &first_parameter_id, ++ uint16_t &first_parameter_id, + +- int16_t &last_parameter_id ++ uint16_t &last_parameter_id + + ); + +@@ -5937,7 +5937,7 @@ std::string get_json_payload_for_user_credential_add_user_command( + */ + void uic_mqtt_dotdot_parse_user_credential_add_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + UserTypeEnum &user_type, + +@@ -5947,7 +5947,7 @@ void uic_mqtt_dotdot_parse_user_credential_add_user( + + std::string &user_name, + +- int16_t &expiring_timeout_minutes, ++ uint16_t &expiring_timeout_minutes, + + UserNameEncodingType &user_name_encoding + +@@ -5977,7 +5977,7 @@ std::string get_json_payload_for_user_credential_modify_user_command( + */ + void uic_mqtt_dotdot_parse_user_credential_modify_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + UserTypeEnum &user_type, + +@@ -5987,7 +5987,7 @@ void uic_mqtt_dotdot_parse_user_credential_modify_user( + + std::string &user_name, + +- int16_t &expiring_timeout_minutes, ++ uint16_t &expiring_timeout_minutes, + + UserNameEncodingType &user_name_encoding + +@@ -6017,7 +6017,7 @@ std::string get_json_payload_for_user_credential_delete_user_command( + */ + void uic_mqtt_dotdot_parse_user_credential_delete_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ); + +@@ -6045,11 +6045,11 @@ std::string get_json_payload_for_user_credential_add_credential_command( + */ + void uic_mqtt_dotdot_parse_user_credential_add_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + + std::string &credential_data + +@@ -6079,11 +6079,11 @@ std::string get_json_payload_for_user_credential_modify_credential_command( + */ + void uic_mqtt_dotdot_parse_user_credential_modify_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + + std::string &credential_data + +@@ -6113,11 +6113,11 @@ std::string get_json_payload_for_user_credential_delete_credential_command( + */ + void uic_mqtt_dotdot_parse_user_credential_delete_credential( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot ++ uint16_t &credential_slot + + ); + +@@ -6199,7 +6199,7 @@ std::string get_json_payload_for_user_credential_delete_all_credentials_for_user + */ + void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ); + +@@ -6227,7 +6227,7 @@ std::string get_json_payload_for_user_credential_delete_all_credentials_for_user + */ + void uic_mqtt_dotdot_parse_user_credential_delete_all_credentials_for_user_by_type( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type + +@@ -6257,13 +6257,13 @@ std::string get_json_payload_for_user_credential_credential_learn_start_add_comm + */ + void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_add( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + +- int8_t &credential_learn_timeout ++ uint8_t &credential_learn_timeout + + ); + +@@ -6291,13 +6291,13 @@ std::string get_json_payload_for_user_credential_credential_learn_start_modify_c + */ + void uic_mqtt_dotdot_parse_user_credential_credential_learn_start_modify( + nlohmann::json &jsn, +- int16_t &user_uniqueid, ++ uint16_t &user_uniqueid, + + CredType &credential_type, + +- int16_t &credential_slot, ++ uint16_t &credential_slot, + +- int8_t &credential_learn_timeout ++ uint8_t &credential_learn_timeout + + ); + +@@ -6340,13 +6340,13 @@ void uic_mqtt_dotdot_parse_user_credential_credential_association( + nlohmann::json &jsn, + CredType &credential_type, + +- int16_t &source_user_uniqueid, ++ uint16_t &source_user_uniqueid, + +- int16_t &source_credential_slot, ++ uint16_t &source_credential_slot, + +- int16_t &destination_user_uniqueid, ++ uint16_t &destination_user_uniqueid, + +- int16_t &destination_credential_slot ++ uint16_t &destination_credential_slot + + ); + +@@ -6374,7 +6374,7 @@ std::string get_json_payload_for_user_credential_get_user_checksum_command( + */ + void uic_mqtt_dotdot_parse_user_credential_get_user_checksum( + nlohmann::json &jsn, +- int16_t &user_uniqueid ++ uint16_t &user_uniqueid + + ); + +@@ -6628,9 +6628,9 @@ void uic_mqtt_dotdot_parse_unify_humidity_control_setpoint_set( + nlohmann::json &jsn, + SetpointType &type, + +- int8_t &precision, ++ uint8_t &precision, + +- int8_t &scale, ++ uint8_t &scale, + + int32_t &value + +diff --git a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp +index 91713c17a0..295e2af47e 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp ++++ b/components/uic_dotdot_mqtt/zap-generated/src/dotdot_mqtt_group_commands.cpp +@@ -3212,7 +3212,7 @@ static void uic_mqtt_dotdot_on_by_group_groups_get_group_membership( + + + uic_mqtt_dotdot_groups_command_get_group_membership_fields_t fields; +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -3301,7 +3301,7 @@ static void uic_mqtt_dotdot_on_by_group_groups_get_group_membership_response( + + + uic_mqtt_dotdot_groups_command_get_group_membership_response_fields_t fields; +- std::vector group_list; ++ std::vector group_list; + + + nlohmann::json jsn; +@@ -5028,7 +5028,7 @@ static void uic_mqtt_dotdot_on_by_group_scenes_get_scene_membership_response( + + + uic_mqtt_dotdot_scenes_command_get_scene_membership_response_fields_t fields; +- std::vector scene_list; ++ std::vector scene_list; + + + nlohmann::json jsn; +@@ -21500,7 +21500,7 @@ static void uic_mqtt_dotdot_on_by_group_electrical_measurement_get_profile_info_ + + + uic_mqtt_dotdot_electrical_measurement_command_get_profile_info_response_fields_t fields; +- std::vector list_of_attributes; ++ std::vector list_of_attributes; + + + nlohmann::json jsn; +@@ -21681,7 +21681,7 @@ static void uic_mqtt_dotdot_on_by_group_electrical_measurement_get_measurement_p + + + uic_mqtt_dotdot_electrical_measurement_command_get_measurement_profile_response_fields_t fields; +- std::vector intervals; ++ std::vector intervals; + + + nlohmann::json jsn; +diff --git a/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include b/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include +index 85fbbbd53f..89a5002b0f 100644 +--- a/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include ++++ b/components/uic_dotdot_mqtt/zap-generated/test/dotdot_mqtt_test.include +@@ -29,7 +29,7 @@ static sl_status_t uic_mqtt_dotdot_identify_identify_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t identify_time ++ uint16_t identify_time + + ) { + uic_mqtt_dotdot_identify_identify_callback_count++; +@@ -42,7 +42,7 @@ static sl_status_t uic_mqtt_dotdot_identify_identify_query_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t timeout ++ uint16_t timeout + + ) { + uic_mqtt_dotdot_identify_identify_query_response_callback_count++; +@@ -81,7 +81,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -98,7 +98,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- int16_t group_id ++ uint16_t group_id + + ) { + uic_mqtt_dotdot_groups_add_group_response_callback_count++; +@@ -111,7 +111,7 @@ static sl_status_t uic_mqtt_dotdot_groups_view_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t group_id ++ uint16_t group_id + + ) { + uic_mqtt_dotdot_groups_view_group_callback_count++; +@@ -126,7 +126,7 @@ static sl_status_t uic_mqtt_dotdot_groups_view_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -142,7 +142,7 @@ static sl_status_t uic_mqtt_dotdot_groups_get_group_membership_callback_func( + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t group_list_count, +- const int16_t *group_list ++ const uint16_t *group_list + + ) { + uic_mqtt_dotdot_groups_get_group_membership_callback_count++; +@@ -155,10 +155,10 @@ static sl_status_t uic_mqtt_dotdot_groups_get_group_membership_response_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t capacity, ++ uint8_t capacity, + + uint8_t group_list_count, +- const int16_t *group_list ++ const uint16_t *group_list + + ) { + uic_mqtt_dotdot_groups_get_group_membership_response_callback_count++; +@@ -171,7 +171,7 @@ static sl_status_t uic_mqtt_dotdot_groups_remove_group_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t group_id ++ uint16_t group_id + + ) { + uic_mqtt_dotdot_groups_remove_group_callback_count++; +@@ -186,7 +186,7 @@ static sl_status_t uic_mqtt_dotdot_groups_remove_group_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t status, + +- int16_t group_id ++ uint16_t group_id + + ) { + uic_mqtt_dotdot_groups_remove_group_response_callback_count++; +@@ -210,7 +210,7 @@ static sl_status_t uic_mqtt_dotdot_groups_add_group_if_identifying_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t group_id, ++ uint16_t group_id, + + const char* group_name + +@@ -225,18 +225,18 @@ static sl_status_t uic_mqtt_dotdot_scenes_add_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets, + +- int8_t transition_time100ms ++ uint8_t transition_time100ms + + ) { + uic_mqtt_dotdot_scenes_add_scene_callback_count++; +@@ -251,9 +251,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_add_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_add_scene_response_callback_count++; +@@ -266,9 +266,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_view_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_view_scene_callback_count++; +@@ -283,13 +283,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_view_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -305,9 +305,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_remove_scene_callback_count++; +@@ -322,9 +322,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_remove_scene_response_callback_count++; +@@ -337,7 +337,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_all_scenes_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid ++ uint16_t groupid + + ) { + uic_mqtt_dotdot_scenes_remove_all_scenes_callback_count++; +@@ -352,7 +352,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_fu + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid ++ uint16_t groupid + + ) { + uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback_count++; +@@ -365,9 +365,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_store_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_store_scene_callback_count++; +@@ -382,9 +382,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_store_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_store_scene_response_callback_count++; +@@ -397,11 +397,11 @@ static sl_status_t uic_mqtt_dotdot_scenes_recall_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time ++ uint16_t transition_time + + ) { + uic_mqtt_dotdot_scenes_recall_scene_callback_count++; +@@ -414,7 +414,7 @@ static sl_status_t uic_mqtt_dotdot_scenes_get_scene_membership_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid ++ uint16_t groupid + + ) { + uic_mqtt_dotdot_scenes_get_scene_membership_callback_count++; +@@ -429,12 +429,12 @@ static sl_status_t uic_mqtt_dotdot_scenes_get_scene_membership_response_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- int8_t capacity, ++ uint8_t capacity, + +- uint8_t * groupid, ++ uint16_t groupid, + + uint8_t scene_list_count, +- const int8_t *scene_list ++ const uint8_t *scene_list + + ) { + uic_mqtt_dotdot_scenes_get_scene_membership_response_callback_count++; +@@ -447,13 +447,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_add_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -471,9 +471,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback_f + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback_count++; +@@ -486,9 +486,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid ++ uint8_t sceneid + + ) { + uic_mqtt_dotdot_scenes_enhanced_view_scene_callback_count++; +@@ -503,13 +503,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback_ + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * groupid, ++ uint16_t groupid, + +- int8_t sceneid, ++ uint8_t sceneid, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * scene_name, ++ const char* scene_name, + + uint8_t extension_field_sets_count, + const SExtensionFieldSetList *extension_field_sets +@@ -527,13 +527,13 @@ static sl_status_t uic_mqtt_dotdot_scenes_copy_scene_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t mode, + +- uint8_t * group_identifier_from, ++ uint16_t group_identifier_from, + +- int8_t scene_identifier_from, ++ uint8_t scene_identifier_from, + +- uint8_t * group_identifier_to, ++ uint16_t group_identifier_to, + +- int8_t scene_identifier_to ++ uint8_t scene_identifier_to + + ) { + uic_mqtt_dotdot_scenes_copy_scene_callback_count++; +@@ -548,9 +548,9 @@ static sl_status_t uic_mqtt_dotdot_scenes_copy_scene_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + zclStatus status, + +- uint8_t * group_identifier_from, ++ uint16_t group_identifier_from, + +- int8_t scene_identifier_from ++ uint8_t scene_identifier_from + + ) { + uic_mqtt_dotdot_scenes_copy_scene_response_callback_count++; +@@ -598,7 +598,7 @@ static sl_status_t uic_mqtt_dotdot_on_off_off_with_effect_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + OffWithEffectEffectIdentifier effect_identifier, + +- int8_t effect_variant ++ uint8_t effect_variant + + ) { + uic_mqtt_dotdot_on_off_off_with_effect_callback_count++; +@@ -624,9 +624,9 @@ static sl_status_t uic_mqtt_dotdot_on_off_on_with_timed_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t on_off_control, + +- int16_t on_time, ++ uint16_t on_time, + +- int16_t off_wait_time ++ uint16_t off_wait_time + + ) { + uic_mqtt_dotdot_on_off_on_with_timed_off_callback_count++; +@@ -639,9 +639,9 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_level_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t level, ++ uint8_t level, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -660,7 +660,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -679,9 +679,9 @@ static sl_status_t uic_mqtt_dotdot_level_step_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -713,9 +713,9 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_level_with_on_off_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t level, ++ uint8_t level, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -734,7 +734,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_with_on_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -753,9 +753,9 @@ static sl_status_t uic_mqtt_dotdot_level_step_with_on_off_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + MoveStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -787,7 +787,7 @@ static sl_status_t uic_mqtt_dotdot_level_move_to_closest_frequency_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t frequency ++ uint16_t frequency + + ) { + uic_mqtt_dotdot_level_move_to_closest_frequency_callback_count++; +@@ -802,7 +802,7 @@ static sl_status_t uic_mqtt_dotdot_alarms_reset_alarm_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t alarm_code, + +- uint8_t cluster_identifier ++ uint16_t cluster_identifier + + ) { + uic_mqtt_dotdot_alarms_reset_alarm_callback_count++; +@@ -817,7 +817,7 @@ static sl_status_t uic_mqtt_dotdot_alarms_alarm_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t alarm_code, + +- uint8_t cluster_identifier ++ uint16_t cluster_identifier + + ) { + uic_mqtt_dotdot_alarms_alarm_callback_count++; +@@ -845,9 +845,9 @@ static sl_status_t uic_mqtt_dotdot_alarms_get_alarm_response_callback_func( + + uint8_t alarm_code, + +- uint8_t cluster_identifier, ++ uint16_t cluster_identifier, + +- int32_t time_stamp ++ uint32_t time_stamp + + ) { + uic_mqtt_dotdot_alarms_get_alarm_response_callback_count++; +@@ -895,7 +895,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_check_in_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + bool start_fast_polling, + +- int16_t fast_poll_timeout ++ uint16_t fast_poll_timeout + + ) { + uic_mqtt_dotdot_poll_control_check_in_response_callback_count++; +@@ -919,7 +919,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback_ + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int32_t new_long_poll_interval ++ uint32_t new_long_poll_interval + + ) { + uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback_count++; +@@ -932,7 +932,7 @@ static sl_status_t uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t new_short_poll_interval ++ uint16_t new_short_poll_interval + + ) { + uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback_count++; +@@ -945,7 +945,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_lock_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_lock_door_callback_count++; +@@ -971,7 +971,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unlock_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_unlock_door_callback_count++; +@@ -997,7 +997,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_toggle_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_toggle_callback_count++; +@@ -1023,9 +1023,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t timeout_in_seconds, ++ uint16_t timeout_in_seconds, + +- uint8_t pin_or_rfid_code ++ const char* pin_or_rfid_code + + ) { + uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback_count++; +@@ -1051,7 +1051,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_log_record_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t log_index ++ uint16_t log_index + + ) { + uic_mqtt_dotdot_door_lock_get_log_record_callback_count++; +@@ -1064,19 +1064,19 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_log_record_response_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t log_entryid, ++ uint16_t log_entryid, + +- int32_t timestamp, ++ uint32_t timestamp, + + GetLogRecordResponseEventType event_type, + + DrlkOperEventSource source_operation_event, + +- int8_t event_id_or_alarm_code, ++ uint8_t event_id_or_alarm_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin ++ const char* pin + + ) { + uic_mqtt_dotdot_door_lock_get_log_record_response_callback_count++; +@@ -1089,13 +1089,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t pin ++ const char* pin + + ) { + uic_mqtt_dotdot_door_lock_set_pin_code_callback_count++; +@@ -1121,7 +1121,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_pin_code_callback_count++; +@@ -1134,13 +1134,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t code ++ const char* code + + ) { + uic_mqtt_dotdot_door_lock_get_pin_code_response_callback_count++; +@@ -1153,7 +1153,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_pin_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_clear_pin_code_callback_count++; +@@ -1203,7 +1203,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_status_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status + +@@ -1231,7 +1231,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_status_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_user_status_callback_count++; +@@ -1244,7 +1244,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_status_response_callback_f + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status + +@@ -1259,19 +1259,19 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid, ++ uint16_t userid, + + uint8_t days_mask, + +- int8_t start_hour, ++ uint8_t start_hour, + +- int8_t start_minute, ++ uint8_t start_minute, + +- int8_t end_hour, ++ uint8_t end_hour, + +- int8_t end_minute ++ uint8_t end_minute + + ) { + uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback_count++; +@@ -1297,9 +1297,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback_count++; +@@ -1312,21 +1312,21 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t scheduleid, ++ uint8_t scheduleid, + +- int16_t userid, ++ uint16_t userid, + + zclStatus status, + + uint8_t days_mask, + +- int8_t start_hour, ++ uint8_t start_hour, + +- int8_t start_minute, ++ uint8_t start_minute, + +- int8_t end_hour, ++ uint8_t end_hour, + +- int8_t end_minute ++ uint8_t end_minute + + ) { + uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback_count++; +@@ -1339,9 +1339,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback_count++; +@@ -1367,13 +1367,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid, ++ uint16_t userid, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time ++ uint32_t local_end_time + + ) { + uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback_count++; +@@ -1399,9 +1399,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_func + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback_count++; +@@ -1414,15 +1414,15 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t scheduleid, ++ uint8_t scheduleid, + +- int16_t userid, ++ uint16_t userid, + + zclStatus status, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time ++ uint32_t local_end_time + + ) { + uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback_count++; +@@ -1435,9 +1435,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * scheduleid, ++ uint8_t scheduleid, + +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback_count++; +@@ -1463,11 +1463,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * holiday_scheduleid, ++ uint8_t holiday_scheduleid, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time, ++ uint32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -1495,7 +1495,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * holiday_scheduleid ++ uint8_t holiday_scheduleid + + ) { + uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback_count++; +@@ -1508,13 +1508,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t holiday_scheduleid, ++ uint8_t holiday_scheduleid, + + zclStatus status, + +- int32_t local_start_time, ++ uint32_t local_start_time, + +- int32_t local_end_time, ++ uint32_t local_end_time, + + DrlkOperMode operating_mode_during_holiday + +@@ -1529,7 +1529,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * holiday_scheduleid ++ uint8_t holiday_scheduleid + + ) { + uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback_count++; +@@ -1555,7 +1555,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_type_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkUserType user_type + +@@ -1583,7 +1583,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_type_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_user_type_callback_count++; +@@ -1596,7 +1596,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_type_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserType user_type + +@@ -1611,13 +1611,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid, ++ uint16_t userid, + + DrlkSettableUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t rfid_code ++ const char* rfid_code + + ) { + uic_mqtt_dotdot_door_lock_set_rfid_code_callback_count++; +@@ -1643,7 +1643,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_get_rfid_code_callback_count++; +@@ -1656,13 +1656,13 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t userid, ++ uint16_t userid, + + DrlkUserStatus user_status, + + DrlkUserType user_type, + +- uint8_t rfid_code ++ const char* rfid_code + + ) { + uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback_count++; +@@ -1675,7 +1675,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t * userid ++ uint16_t userid + + ) { + uic_mqtt_dotdot_door_lock_clear_rfid_code_callback_count++; +@@ -1727,11 +1727,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_user_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + DataOperationTypeEnum operation_type, + +- int16_t user_index, ++ uint16_t user_index, + + const char* user_name, + +- int32_t user_uniqueid, ++ uint32_t user_uniqueid, + + DrlkSettableUserStatus user_status, + +@@ -1750,7 +1750,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_get_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_index ++ uint16_t user_index + + ) { + uic_mqtt_dotdot_door_lock_get_user_callback_count++; +@@ -1774,7 +1774,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_clear_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_index ++ uint16_t user_index + + ) { + uic_mqtt_dotdot_door_lock_clear_user_callback_count++; +@@ -1791,11 +1791,11 @@ static sl_status_t uic_mqtt_dotdot_door_lock_operating_event_notification_callba + + OperatingEventNotificationOperationEventCode operation_event_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin, ++ const char* pin, + +- int32_t local_time, ++ uint32_t local_time, + + const char* data + +@@ -1814,15 +1814,15 @@ static sl_status_t uic_mqtt_dotdot_door_lock_programming_event_notification_call + + ProgrammingEventNotificationProgramEventCode program_event_code, + +- int16_t userid, ++ uint16_t userid, + +- uint8_t pin, ++ const char* pin, + + DrlkUserType user_type, + + DrlkUserStatus user_status, + +- int32_t local_time, ++ uint32_t local_time, + + const char* data + +@@ -1841,9 +1841,9 @@ static sl_status_t uic_mqtt_dotdot_door_lock_set_credential_callback_func( + + CredentialStruct credential, + +- uint8_t credential_data, ++ const char* credential_data, + +- int16_t user_index, ++ uint16_t user_index, + + DrlkSettableUserStatus user_status, + +@@ -1908,7 +1908,7 @@ static sl_status_t uic_mqtt_dotdot_door_lock_unbolt_door_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t pin_code ++ const char* pin_code + + ) { + uic_mqtt_dotdot_door_lock_unbolt_door_callback_count++; +@@ -1954,7 +1954,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t lift_value ++ uint16_t lift_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_lift_value_callback_count++; +@@ -1967,7 +1967,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t percentage_lift_value ++ uint8_t percentage_lift_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback_count++; +@@ -1980,7 +1980,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t tilt_value ++ uint16_t tilt_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback_count++; +@@ -1993,7 +1993,7 @@ static sl_status_t uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callbac + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t percentage_tilt_value ++ uint8_t percentage_tilt_value + + ) { + uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback_count++; +@@ -2006,7 +2006,7 @@ static sl_status_t uic_mqtt_dotdot_barrier_control_go_to_percent_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t percent_open ++ uint8_t percent_open + + ) { + uic_mqtt_dotdot_barrier_control_go_to_percent_callback_count++; +@@ -2085,17 +2085,17 @@ static sl_status_t uic_mqtt_dotdot_thermostat_get_relay_status_log_response_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t time_of_day, ++ uint16_t time_of_day, + + uint8_t relay_status, + + int16_t local_temperature, + +- int8_t humidity_percentage, ++ uint8_t humidity_percentage, + + int16_t set_point, + +- int16_t unread_entries ++ uint16_t unread_entries + + ) { + uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback_count++; +@@ -2145,11 +2145,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_hue_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t hue, ++ uint8_t hue, + + CCDirection direction, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2168,7 +2168,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_hue_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -2187,9 +2187,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_hue_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int8_t transition_time, ++ uint8_t transition_time, + + uint8_t options_mask, + +@@ -2206,9 +2206,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_saturation_callback_fun + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2227,7 +2227,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_saturation_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- int8_t rate, ++ uint8_t rate, + + uint8_t options_mask, + +@@ -2246,9 +2246,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_saturation_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- int8_t step_size, ++ uint8_t step_size, + +- int8_t transition_time, ++ uint8_t transition_time, + + uint8_t options_mask, + +@@ -2265,11 +2265,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_call + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t hue, ++ uint8_t hue, + +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2286,11 +2286,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_color_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t colorx, ++ uint16_t colorx, + +- int16_t colory, ++ uint16_t colory, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2330,7 +2330,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_color_callback_func( + + int16_t stepy, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2347,9 +2347,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_to_color_temperature_callb + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t color_temperature_mireds, ++ uint16_t color_temperature_mireds, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2366,11 +2366,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback_f + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t enhanced_hue, ++ uint16_t enhanced_hue, + + CCDirection direction, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2389,7 +2389,7 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_hue_callback_func + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- int16_t rate, ++ uint16_t rate, + + uint8_t options_mask, + +@@ -2408,9 +2408,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_step_hue_callback_func + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- int16_t step_size, ++ uint16_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2427,11 +2427,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_satura + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t enhanced_hue, ++ uint16_t enhanced_hue, + +- int8_t saturation, ++ uint8_t saturation, + +- int16_t transition_time, ++ uint16_t transition_time, + + uint8_t options_mask, + +@@ -2454,9 +2454,9 @@ static sl_status_t uic_mqtt_dotdot_color_control_color_loop_set_callback_func( + + CCColorLoopDirection direction, + +- int16_t time, ++ uint16_t time, + +- int16_t start_hue, ++ uint16_t start_hue, + + uint8_t options_mask, + +@@ -2490,11 +2490,11 @@ static sl_status_t uic_mqtt_dotdot_color_control_move_color_temperature_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCMoveMode move_mode, + +- int16_t rate, ++ uint16_t rate, + +- uint8_t * color_temperature_minimum_mireds, ++ uint16_t color_temperature_minimum_mireds, + +- uint8_t * color_temperature_maximum_mireds, ++ uint16_t color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -2513,13 +2513,13 @@ static sl_status_t uic_mqtt_dotdot_color_control_step_color_temperature_callback + uic_mqtt_dotdot_callback_call_type_t callback_type, + CCStepMode step_mode, + +- int16_t step_size, ++ uint16_t step_size, + +- int16_t transition_time, ++ uint16_t transition_time, + +- uint8_t * color_temperature_minimum_mireds, ++ uint16_t color_temperature_minimum_mireds, + +- uint8_t * color_temperature_maximum_mireds, ++ uint16_t color_temperature_maximum_mireds, + + uint8_t options_mask, + +@@ -2538,7 +2538,7 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + ZoneEnrollResponseEnrollResponseCode enroll_response_code, + +- int8_t zoneid ++ uint8_t zoneid + + ) { + uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback_count++; +@@ -2555,9 +2555,9 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_status_change_notification_call + + uint8_t extended_status, + +- int8_t zoneid, ++ uint8_t zoneid, + +- int16_t delay ++ uint16_t delay + + ) { + uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback_count++; +@@ -2583,7 +2583,7 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + IasZoneType zone_type, + +- int16_t manufacturer_code ++ uint16_t manufacturer_code + + ) { + uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback_count++; +@@ -2596,9 +2596,9 @@ static sl_status_t uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t test_mode_duration, ++ uint8_t test_mode_duration, + +- int8_t current_zone_sensitivity_level ++ uint8_t current_zone_sensitivity_level + + ) { + uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback_count++; +@@ -2613,9 +2613,9 @@ static sl_status_t uic_mqtt_dotdot_iaswd_start_warning_callback_func( + uic_mqtt_dotdot_callback_call_type_t callback_type, + uint8_t siren_configuration, + +- int16_t warning_duration, ++ uint16_t warning_duration, + +- int8_t strobe_duty_cycle, ++ uint8_t strobe_duty_cycle, + + IaswdLevel strobe_level + +@@ -2643,14 +2643,14 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_profile_info_respo + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int8_t profile_count, ++ uint8_t profile_count, + + ProfileIntervalPeriod profile_interval_period, + +- int8_t max_number_of_intervals, ++ uint8_t max_number_of_intervals, + + uint8_t list_of_attributes_count, +- const uint8_t *list_of_attributes ++ const uint16_t *list_of_attributes + + ) { + uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback_count++; +@@ -2674,18 +2674,18 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t start_time, ++ uint32_t start_time, + + GetMeasurementProfileResponseStatus status, + + ProfileIntervalPeriod profile_interval_period, + +- int8_t number_of_intervals_delivered, ++ uint8_t number_of_intervals_delivered, + +- uint8_t attribute_id, ++ uint16_t attribute_id, + + uint8_t intervals_count, +- const int8_t *intervals ++ const uint8_t *intervals + + ) { + uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback_count++; +@@ -2698,11 +2698,11 @@ static sl_status_t uic_mqtt_dotdot_electrical_measurement_get_measurement_profil + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- uint8_t attributeid, ++ uint16_t attributeid, + +- uint8_t start_time, ++ uint32_t start_time, + +- int8_t number_of_intervals ++ uint8_t number_of_intervals + + ) { + uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback_count++; +@@ -2721,13 +2721,13 @@ static sl_status_t uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_ca + + bool transmission_successful, + +- int16_t transmission_time_ms, ++ uint16_t transmission_time_ms, + + int8_t tx_powerd_bm, + +- int8_t tx_channel, ++ uint8_t tx_channel, + +- int8_t routing_attempts, ++ uint8_t routing_attempts, + + bool route_changed, + +@@ -2743,7 +2743,7 @@ static sl_status_t uic_mqtt_dotdot_protocol_controller_rf_telemetry_tx_report_ca + + int8_t ackrssi, + +- int8_t ack_channel, ++ uint8_t ack_channel, + + const char* last_route_failed_link_functionalunid, + +@@ -2836,7 +2836,7 @@ static sl_status_t uic_mqtt_dotdot_binding_bind_callback_func( + + const char* destination_unid, + +- int8_t destination_ep ++ uint8_t destination_ep + + ) { + uic_mqtt_dotdot_binding_bind_callback_count++; +@@ -2853,7 +2853,7 @@ static sl_status_t uic_mqtt_dotdot_binding_unbind_callback_func( + + const char* destination_unid, + +- int8_t destination_ep ++ uint8_t destination_ep + + ) { + uic_mqtt_dotdot_binding_unbind_callback_count++; +@@ -2911,7 +2911,7 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_discover_parameter_c + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t parameter_id ++ uint16_t parameter_id + + ) { + uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback_count++; +@@ -2935,7 +2935,7 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_set_parameter_callba + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t parameter_id, ++ uint16_t parameter_id, + + int64_t value + +@@ -2950,9 +2950,9 @@ static sl_status_t uic_mqtt_dotdot_configuration_parameters_discover_parameter_r + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t first_parameter_id, ++ uint16_t first_parameter_id, + +- int16_t last_parameter_id ++ uint16_t last_parameter_id + + ) { + uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback_count++; +@@ -2965,7 +2965,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_add_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + UserTypeEnum user_type, + +@@ -2975,7 +2975,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_add_user_callback_func( + + const char* user_name, + +- int16_t expiring_timeout_minutes, ++ uint16_t expiring_timeout_minutes, + + UserNameEncodingType user_name_encoding + +@@ -2990,7 +2990,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_modify_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + UserTypeEnum user_type, + +@@ -3000,7 +3000,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_modify_user_callback_func( + + const char* user_name, + +- int16_t expiring_timeout_minutes, ++ uint16_t expiring_timeout_minutes, + + UserNameEncodingType user_name_encoding + +@@ -3015,7 +3015,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_delete_user_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ) { + uic_mqtt_dotdot_user_credential_delete_user_callback_count++; +@@ -3028,11 +3028,11 @@ static sl_status_t uic_mqtt_dotdot_user_credential_add_credential_callback_func( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + + const char* credential_data + +@@ -3047,11 +3047,11 @@ static sl_status_t uic_mqtt_dotdot_user_credential_modify_credential_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + + const char* credential_data + +@@ -3066,11 +3066,11 @@ static sl_status_t uic_mqtt_dotdot_user_credential_delete_credential_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot ++ uint16_t credential_slot + + ) { + uic_mqtt_dotdot_user_credential_delete_credential_callback_count++; +@@ -3118,7 +3118,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_for_us + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ) { + uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_count++; +@@ -3131,7 +3131,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_delete_all_credentials_for_us + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type + +@@ -3146,13 +3146,13 @@ static sl_status_t uic_mqtt_dotdot_user_credential_credential_learn_start_add_ca + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + +- int8_t credential_learn_timeout ++ uint8_t credential_learn_timeout + + ) { + uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_count++; +@@ -3165,13 +3165,13 @@ static sl_status_t uic_mqtt_dotdot_user_credential_credential_learn_start_modify + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid, ++ uint16_t user_uniqueid, + + CredType credential_type, + +- int16_t credential_slot, ++ uint16_t credential_slot, + +- int8_t credential_learn_timeout ++ uint8_t credential_learn_timeout + + ) { + uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_count++; +@@ -3197,13 +3197,13 @@ static sl_status_t uic_mqtt_dotdot_user_credential_credential_association_callba + uic_mqtt_dotdot_callback_call_type_t callback_type, + CredType credential_type, + +- int16_t source_user_uniqueid, ++ uint16_t source_user_uniqueid, + +- int16_t source_credential_slot, ++ uint16_t source_credential_slot, + +- int16_t destination_user_uniqueid, ++ uint16_t destination_user_uniqueid, + +- int16_t destination_credential_slot ++ uint16_t destination_credential_slot + + ) { + uic_mqtt_dotdot_user_credential_credential_association_callback_count++; +@@ -3216,7 +3216,7 @@ static sl_status_t uic_mqtt_dotdot_user_credential_get_user_checksum_callback_fu + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t callback_type, +- int16_t user_uniqueid ++ uint16_t user_uniqueid + + ) { + uic_mqtt_dotdot_user_credential_get_user_checksum_callback_count++; +@@ -3327,9 +3327,9 @@ static sl_status_t uic_mqtt_dotdot_unify_humidity_control_setpoint_set_callback_ + uic_mqtt_dotdot_callback_call_type_t callback_type, + SetpointType type, + +- int8_t precision, ++ uint8_t precision, + +- int8_t scale, ++ uint8_t scale, + + int32_t value + +diff --git a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h +index 3693cf08fb..8027848315 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h ++++ b/components/unify_dotdot_attribute_store/zap-generated/include/unify_dotdot_attribute_store_helpers.h +@@ -63,7 +63,7 @@ bool dotdot_is_supported_basic_zcl_version ( + * + * @returns ZCLVersion attribute + */ +-int8_t dotdot_get_basic_zcl_version( ++uint8_t dotdot_get_basic_zcl_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -83,7 +83,7 @@ sl_status_t dotdot_set_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_zcl_version ++ uint8_t new_zcl_version + ); + + /** +@@ -169,7 +169,7 @@ bool dotdot_is_supported_basic_application_version ( + * + * @returns ApplicationVersion attribute + */ +-int8_t dotdot_get_basic_application_version( ++uint8_t dotdot_get_basic_application_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -189,7 +189,7 @@ sl_status_t dotdot_set_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_application_version ++ uint8_t new_application_version + ); + + /** +@@ -275,7 +275,7 @@ bool dotdot_is_supported_basic_stack_version ( + * + * @returns StackVersion attribute + */ +-int8_t dotdot_get_basic_stack_version( ++uint8_t dotdot_get_basic_stack_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -295,7 +295,7 @@ sl_status_t dotdot_set_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_stack_version ++ uint8_t new_stack_version + ); + + /** +@@ -381,7 +381,7 @@ bool dotdot_is_supported_basic_hw_version ( + * + * @returns HWVersion attribute + */ +-int8_t dotdot_get_basic_hw_version( ++uint8_t dotdot_get_basic_hw_version( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -401,7 +401,7 @@ sl_status_t dotdot_set_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_hw_version ++ uint8_t new_hw_version + ); + + /** +@@ -1135,7 +1135,7 @@ bool dotdot_is_supported_basic_product_code ( + * + * @returns ProductCode attribute + */ +-uint8_t dotdot_get_basic_product_code( ++const char* dotdot_get_basic_product_code( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -1155,7 +1155,7 @@ sl_status_t dotdot_set_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_product_code ++ const char* new_product_code + ); + + /** +@@ -2347,7 +2347,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage ( + * + * @returns MainsVoltage attribute + */ +-int16_t dotdot_get_power_configuration_mains_voltage( ++uint16_t dotdot_get_power_configuration_mains_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2367,7 +2367,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage ++ uint16_t new_mains_voltage + ); + + /** +@@ -2453,7 +2453,7 @@ bool dotdot_is_supported_power_configuration_mains_frequency ( + * + * @returns MainsFrequency attribute + */ +-int8_t dotdot_get_power_configuration_mains_frequency( ++uint8_t dotdot_get_power_configuration_mains_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2473,7 +2473,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_mains_frequency ++ uint8_t new_mains_frequency + ); + + /** +@@ -2665,7 +2665,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_min_threshold ( + * + * @returns MainsVoltageMinThreshold attribute + */ +-int16_t dotdot_get_power_configuration_mains_voltage_min_threshold( ++uint16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2685,7 +2685,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_min_threshold ++ uint16_t new_mains_voltage_min_threshold + ); + + /** +@@ -2771,7 +2771,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_max_threshold ( + * + * @returns MainsVoltageMaxThreshold attribute + */ +-int16_t dotdot_get_power_configuration_mains_voltage_max_threshold( ++uint16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2791,7 +2791,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_max_threshold ++ uint16_t new_mains_voltage_max_threshold + ); + + /** +@@ -2877,7 +2877,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_dwell_trip_point ( + * + * @returns MainsVoltageDwellTripPoint attribute + */ +-int16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( ++uint16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -2897,7 +2897,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_dwell_trip_point ++ uint16_t new_mains_voltage_dwell_trip_point + ); + + /** +@@ -2983,7 +2983,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage ( + * + * @returns BatteryVoltage attribute + */ +-int8_t dotdot_get_power_configuration_battery_voltage( ++uint8_t dotdot_get_power_configuration_battery_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3003,7 +3003,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage ++ uint8_t new_battery_voltage + ); + + /** +@@ -3089,7 +3089,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_remaining ( + * + * @returns BatteryPercentageRemaining attribute + */ +-int8_t dotdot_get_power_configuration_battery_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3109,7 +3109,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_remaining ++ uint8_t new_battery_percentage_remaining + ); + + /** +@@ -3410,7 +3410,7 @@ bool dotdot_is_supported_power_configuration_batterya_hr_rating ( + * + * @returns BatteryAHrRating attribute + */ +-int16_t dotdot_get_power_configuration_batterya_hr_rating( ++uint16_t dotdot_get_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3430,7 +3430,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_batterya_hr_rating ++ uint16_t new_batterya_hr_rating + ); + + /** +@@ -3516,7 +3516,7 @@ bool dotdot_is_supported_power_configuration_battery_quantity ( + * + * @returns BatteryQuantity attribute + */ +-int8_t dotdot_get_power_configuration_battery_quantity( ++uint8_t dotdot_get_power_configuration_battery_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3536,7 +3536,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_quantity ++ uint8_t new_battery_quantity + ); + + /** +@@ -3622,7 +3622,7 @@ bool dotdot_is_supported_power_configuration_battery_rated_voltage ( + * + * @returns BatteryRatedVoltage attribute + */ +-int8_t dotdot_get_power_configuration_battery_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3642,7 +3642,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_rated_voltage ++ uint8_t new_battery_rated_voltage + ); + + /** +@@ -3834,7 +3834,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_min_threshold ( + * + * @returns BatteryVoltageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3854,7 +3854,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_min_threshold ++ uint8_t new_battery_voltage_min_threshold + ); + + /** +@@ -3940,7 +3940,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold1 ( + * + * @returns BatteryVoltageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -3960,7 +3960,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold1 ++ uint8_t new_battery_voltage_threshold1 + ); + + /** +@@ -4046,7 +4046,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold2 ( + * + * @returns BatteryVoltageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4066,7 +4066,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold2 ++ uint8_t new_battery_voltage_threshold2 + ); + + /** +@@ -4152,7 +4152,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold3 ( + * + * @returns BatteryVoltageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4172,7 +4172,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold3 ++ uint8_t new_battery_voltage_threshold3 + ); + + /** +@@ -4258,7 +4258,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_min_threshold ( + * + * @returns BatteryPercentageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4278,7 +4278,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_min_threshold ++ uint8_t new_battery_percentage_min_threshold + ); + + /** +@@ -4364,7 +4364,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold1 ( + * + * @returns BatteryPercentageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4384,7 +4384,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold1 ++ uint8_t new_battery_percentage_threshold1 + ); + + /** +@@ -4470,7 +4470,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold2 ( + * + * @returns BatteryPercentageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4490,7 +4490,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold2 ++ uint8_t new_battery_percentage_threshold2 + ); + + /** +@@ -4576,7 +4576,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold3 ( + * + * @returns BatteryPercentageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4596,7 +4596,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold3 ++ uint8_t new_battery_percentage_threshold3 + ); + + /** +@@ -4788,7 +4788,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage ( + * + * @returns Battery2Voltage attribute + */ +-int8_t dotdot_get_power_configuration_battery2_voltage( ++uint8_t dotdot_get_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4808,7 +4808,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage ++ uint8_t new_battery2_voltage + ); + + /** +@@ -4894,7 +4894,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_remaining ( + * + * @returns Battery2PercentageRemaining attribute + */ +-int8_t dotdot_get_power_configuration_battery2_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -4914,7 +4914,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_remaining ++ uint8_t new_battery2_percentage_remaining + ); + + /** +@@ -5215,7 +5215,7 @@ bool dotdot_is_supported_power_configuration_battery2a_hr_rating ( + * + * @returns Battery2AHrRating attribute + */ +-int16_t dotdot_get_power_configuration_battery2a_hr_rating( ++uint16_t dotdot_get_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5235,7 +5235,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_battery2a_hr_rating ++ uint16_t new_battery2a_hr_rating + ); + + /** +@@ -5321,7 +5321,7 @@ bool dotdot_is_supported_power_configuration_battery2_quantity ( + * + * @returns Battery2Quantity attribute + */ +-int8_t dotdot_get_power_configuration_battery2_quantity( ++uint8_t dotdot_get_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5341,7 +5341,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_quantity ++ uint8_t new_battery2_quantity + ); + + /** +@@ -5427,7 +5427,7 @@ bool dotdot_is_supported_power_configuration_battery2_rated_voltage ( + * + * @returns Battery2RatedVoltage attribute + */ +-int8_t dotdot_get_power_configuration_battery2_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5447,7 +5447,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_rated_voltage ++ uint8_t new_battery2_rated_voltage + ); + + /** +@@ -5639,7 +5639,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_min_threshold ( + * + * @returns Battery2VoltageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5659,7 +5659,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_min_threshold ++ uint8_t new_battery2_voltage_min_threshold + ); + + /** +@@ -5745,7 +5745,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold1 ( + * + * @returns Battery2VoltageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5765,7 +5765,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold1 ++ uint8_t new_battery2_voltage_threshold1 + ); + + /** +@@ -5851,7 +5851,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold2 ( + * + * @returns Battery2VoltageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5871,7 +5871,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold2 ++ uint8_t new_battery2_voltage_threshold2 + ); + + /** +@@ -5957,7 +5957,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold3 ( + * + * @returns Battery2VoltageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -5977,7 +5977,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold3 ++ uint8_t new_battery2_voltage_threshold3 + ); + + /** +@@ -6063,7 +6063,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_min_threshold ( + * + * @returns Battery2PercentageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6083,7 +6083,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_min_threshold ++ uint8_t new_battery2_percentage_min_threshold + ); + + /** +@@ -6169,7 +6169,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold1 ( + * + * @returns Battery2PercentageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6189,7 +6189,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold1 ++ uint8_t new_battery2_percentage_threshold1 + ); + + /** +@@ -6275,7 +6275,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold2 ( + * + * @returns Battery2PercentageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6295,7 +6295,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold2 ++ uint8_t new_battery2_percentage_threshold2 + ); + + /** +@@ -6381,7 +6381,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold3 ( + * + * @returns Battery2PercentageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6401,7 +6401,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold3 ++ uint8_t new_battery2_percentage_threshold3 + ); + + /** +@@ -6593,7 +6593,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage ( + * + * @returns Battery3Voltage attribute + */ +-int8_t dotdot_get_power_configuration_battery3_voltage( ++uint8_t dotdot_get_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6613,7 +6613,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage ++ uint8_t new_battery3_voltage + ); + + /** +@@ -6699,7 +6699,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_remaining ( + * + * @returns Battery3PercentageRemaining attribute + */ +-int8_t dotdot_get_power_configuration_battery3_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -6719,7 +6719,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_remaining ++ uint8_t new_battery3_percentage_remaining + ); + + /** +@@ -7020,7 +7020,7 @@ bool dotdot_is_supported_power_configuration_battery3a_hr_rating ( + * + * @returns Battery3AHrRating attribute + */ +-int16_t dotdot_get_power_configuration_battery3a_hr_rating( ++uint16_t dotdot_get_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7040,7 +7040,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_battery3a_hr_rating ++ uint16_t new_battery3a_hr_rating + ); + + /** +@@ -7126,7 +7126,7 @@ bool dotdot_is_supported_power_configuration_battery3_quantity ( + * + * @returns Battery3Quantity attribute + */ +-int8_t dotdot_get_power_configuration_battery3_quantity( ++uint8_t dotdot_get_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7146,7 +7146,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_quantity ++ uint8_t new_battery3_quantity + ); + + /** +@@ -7232,7 +7232,7 @@ bool dotdot_is_supported_power_configuration_battery3_rated_voltage ( + * + * @returns Battery3RatedVoltage attribute + */ +-int8_t dotdot_get_power_configuration_battery3_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7252,7 +7252,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_rated_voltage ++ uint8_t new_battery3_rated_voltage + ); + + /** +@@ -7444,7 +7444,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_min_threshold ( + * + * @returns Battery3VoltageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7464,7 +7464,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_min_threshold ++ uint8_t new_battery3_voltage_min_threshold + ); + + /** +@@ -7550,7 +7550,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold1 ( + * + * @returns Battery3VoltageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7570,7 +7570,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold1 ++ uint8_t new_battery3_voltage_threshold1 + ); + + /** +@@ -7656,7 +7656,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold2 ( + * + * @returns Battery3VoltageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7676,7 +7676,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold2 ++ uint8_t new_battery3_voltage_threshold2 + ); + + /** +@@ -7762,7 +7762,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold3 ( + * + * @returns Battery3VoltageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7782,7 +7782,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold3 ++ uint8_t new_battery3_voltage_threshold3 + ); + + /** +@@ -7868,7 +7868,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_min_threshold ( + * + * @returns Battery3PercentageMinThreshold attribute + */ +-int8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7888,7 +7888,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_min_threshold ++ uint8_t new_battery3_percentage_min_threshold + ); + + /** +@@ -7974,7 +7974,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold1 ( + * + * @returns Battery3PercentageThreshold1 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -7994,7 +7994,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold1 ++ uint8_t new_battery3_percentage_threshold1 + ); + + /** +@@ -8080,7 +8080,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold2 ( + * + * @returns Battery3PercentageThreshold2 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8100,7 +8100,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold2 ++ uint8_t new_battery3_percentage_threshold2 + ); + + /** +@@ -8186,7 +8186,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold3 ( + * + * @returns Battery3PercentageThreshold3 attribute + */ +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8206,7 +8206,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold3 ++ uint8_t new_battery3_percentage_threshold3 + ); + + /** +@@ -8744,7 +8744,7 @@ bool dotdot_is_supported_device_temperature_configuration_over_temp_total_dwell + * + * @returns OverTempTotalDwell attribute + */ +-int16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( ++uint16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -8764,7 +8764,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_over_temp_total_dwell ++ uint16_t new_over_temp_total_dwell + ); + + /** +@@ -9168,7 +9168,7 @@ bool dotdot_is_supported_device_temperature_configuration_low_temp_dwell_trip_po + * + * @returns LowTempDwellTripPoint attribute + */ +-int32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( ++uint32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9188,7 +9188,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_low_temp_dwell_trip_point ++ uint32_t new_low_temp_dwell_trip_point + ); + + /** +@@ -9274,7 +9274,7 @@ bool dotdot_is_supported_device_temperature_configuration_high_temp_dwell_trip_p + * + * @returns HighTempDwellTripPoint attribute + */ +-int32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( ++uint32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9294,7 +9294,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_high_temp_dwell_trip_point ++ uint32_t new_high_temp_dwell_trip_point + ); + + /** +@@ -9408,7 +9408,7 @@ bool dotdot_is_supported_identify_identify_time ( + * + * @returns IdentifyTime attribute + */ +-int16_t dotdot_get_identify_identify_time( ++uint16_t dotdot_get_identify_identify_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9428,7 +9428,7 @@ sl_status_t dotdot_set_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_identify_time ++ uint16_t new_identify_time + ); + + /** +@@ -9676,7 +9676,7 @@ bool dotdot_is_supported_scenes_scene_count ( + * + * @returns SceneCount attribute + */ +-int8_t dotdot_get_scenes_scene_count( ++uint8_t dotdot_get_scenes_scene_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9696,7 +9696,7 @@ sl_status_t dotdot_set_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_scene_count ++ uint8_t new_scene_count + ); + + /** +@@ -9782,7 +9782,7 @@ bool dotdot_is_supported_scenes_current_scene ( + * + * @returns CurrentScene attribute + */ +-int8_t dotdot_get_scenes_current_scene( ++uint8_t dotdot_get_scenes_current_scene( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9802,7 +9802,7 @@ sl_status_t dotdot_set_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_scene ++ uint8_t new_current_scene + ); + + /** +@@ -9888,7 +9888,7 @@ bool dotdot_is_supported_scenes_current_group ( + * + * @returns CurrentGroup attribute + */ +-uint8_t * dotdot_get_scenes_current_group( ++uint16_t dotdot_get_scenes_current_group( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -9908,7 +9908,7 @@ sl_status_t dotdot_set_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t * new_current_group ++ uint16_t new_current_group + ); + + /** +@@ -10661,7 +10661,7 @@ bool dotdot_is_supported_on_off_on_time ( + * + * @returns OnTime attribute + */ +-int16_t dotdot_get_on_off_on_time( ++uint16_t dotdot_get_on_off_on_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -10681,7 +10681,7 @@ sl_status_t dotdot_set_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_time ++ uint16_t new_on_time + ); + + /** +@@ -10767,7 +10767,7 @@ bool dotdot_is_supported_on_off_off_wait_time ( + * + * @returns OffWaitTime attribute + */ +-int16_t dotdot_get_on_off_off_wait_time( ++uint16_t dotdot_get_on_off_off_wait_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -10787,7 +10787,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_off_wait_time ++ uint16_t new_off_wait_time + ); + + /** +@@ -11007,7 +11007,7 @@ bool dotdot_is_supported_level_current_level ( + * + * @returns CurrentLevel attribute + */ +-int8_t dotdot_get_level_current_level( ++uint8_t dotdot_get_level_current_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11027,7 +11027,7 @@ sl_status_t dotdot_set_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_level ++ uint8_t new_current_level + ); + + /** +@@ -11113,7 +11113,7 @@ bool dotdot_is_supported_level_remaining_time ( + * + * @returns RemainingTime attribute + */ +-int16_t dotdot_get_level_remaining_time( ++uint16_t dotdot_get_level_remaining_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11133,7 +11133,7 @@ sl_status_t dotdot_set_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_remaining_time ++ uint16_t new_remaining_time + ); + + /** +@@ -11219,7 +11219,7 @@ bool dotdot_is_supported_level_min_level ( + * + * @returns MinLevel attribute + */ +-int8_t dotdot_get_level_min_level( ++uint8_t dotdot_get_level_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11239,7 +11239,7 @@ sl_status_t dotdot_set_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_level ++ uint8_t new_min_level + ); + + /** +@@ -11325,7 +11325,7 @@ bool dotdot_is_supported_level_max_level ( + * + * @returns MaxLevel attribute + */ +-int8_t dotdot_get_level_max_level( ++uint8_t dotdot_get_level_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11345,7 +11345,7 @@ sl_status_t dotdot_set_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_level ++ uint8_t new_max_level + ); + + /** +@@ -11431,7 +11431,7 @@ bool dotdot_is_supported_level_current_frequency ( + * + * @returns CurrentFrequency attribute + */ +-int16_t dotdot_get_level_current_frequency( ++uint16_t dotdot_get_level_current_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11451,7 +11451,7 @@ sl_status_t dotdot_set_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_frequency ++ uint16_t new_current_frequency + ); + + /** +@@ -11537,7 +11537,7 @@ bool dotdot_is_supported_level_min_frequency ( + * + * @returns MinFrequency attribute + */ +-int16_t dotdot_get_level_min_frequency( ++uint16_t dotdot_get_level_min_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11557,7 +11557,7 @@ sl_status_t dotdot_set_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_frequency ++ uint16_t new_min_frequency + ); + + /** +@@ -11643,7 +11643,7 @@ bool dotdot_is_supported_level_max_frequency ( + * + * @returns MaxFrequency attribute + */ +-int16_t dotdot_get_level_max_frequency( ++uint16_t dotdot_get_level_max_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11663,7 +11663,7 @@ sl_status_t dotdot_set_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_frequency ++ uint16_t new_max_frequency + ); + + /** +@@ -11855,7 +11855,7 @@ bool dotdot_is_supported_level_on_off_transition_time ( + * + * @returns OnOffTransitionTime attribute + */ +-int16_t dotdot_get_level_on_off_transition_time( ++uint16_t dotdot_get_level_on_off_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11875,7 +11875,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_off_transition_time ++ uint16_t new_on_off_transition_time + ); + + /** +@@ -11961,7 +11961,7 @@ bool dotdot_is_supported_level_on_level ( + * + * @returns OnLevel attribute + */ +-int8_t dotdot_get_level_on_level( ++uint8_t dotdot_get_level_on_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -11981,7 +11981,7 @@ sl_status_t dotdot_set_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_on_level ++ uint8_t new_on_level + ); + + /** +@@ -12067,7 +12067,7 @@ bool dotdot_is_supported_level_on_transition_time ( + * + * @returns OnTransitionTime attribute + */ +-int16_t dotdot_get_level_on_transition_time( ++uint16_t dotdot_get_level_on_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12087,7 +12087,7 @@ sl_status_t dotdot_set_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_transition_time ++ uint16_t new_on_transition_time + ); + + /** +@@ -12173,7 +12173,7 @@ bool dotdot_is_supported_level_off_transition_time ( + * + * @returns OffTransitionTime attribute + */ +-int16_t dotdot_get_level_off_transition_time( ++uint16_t dotdot_get_level_off_transition_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12193,7 +12193,7 @@ sl_status_t dotdot_set_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_off_transition_time ++ uint16_t new_off_transition_time + ); + + /** +@@ -12279,7 +12279,7 @@ bool dotdot_is_supported_level_default_move_rate ( + * + * @returns DefaultMoveRate attribute + */ +-int16_t dotdot_get_level_default_move_rate( ++uint16_t dotdot_get_level_default_move_rate( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12299,7 +12299,7 @@ sl_status_t dotdot_set_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_default_move_rate ++ uint16_t new_default_move_rate + ); + + /** +@@ -12385,7 +12385,7 @@ bool dotdot_is_supported_level_start_up_current_level ( + * + * @returns StartUpCurrentLevel attribute + */ +-int8_t dotdot_get_level_start_up_current_level( ++uint8_t dotdot_get_level_start_up_current_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12405,7 +12405,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_start_up_current_level ++ uint8_t new_start_up_current_level + ); + + /** +@@ -12519,7 +12519,7 @@ bool dotdot_is_supported_alarms_alarm_count ( + * + * @returns AlarmCount attribute + */ +-int16_t dotdot_get_alarms_alarm_count( ++uint16_t dotdot_get_alarms_alarm_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12539,7 +12539,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_alarm_count ++ uint16_t new_alarm_count + ); + + /** +@@ -12653,7 +12653,7 @@ bool dotdot_is_supported_time_time ( + * + * @returns Time attribute + */ +-uint8_t dotdot_get_time_time( ++uint32_t dotdot_get_time_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12673,7 +12673,7 @@ sl_status_t dotdot_set_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_time ++ uint32_t new_time + ); + + /** +@@ -12971,7 +12971,7 @@ bool dotdot_is_supported_time_dst_start ( + * + * @returns DstStart attribute + */ +-int32_t dotdot_get_time_dst_start( ++uint32_t dotdot_get_time_dst_start( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -12991,7 +12991,7 @@ sl_status_t dotdot_set_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_dst_start ++ uint32_t new_dst_start + ); + + /** +@@ -13077,7 +13077,7 @@ bool dotdot_is_supported_time_dst_end ( + * + * @returns DstEnd attribute + */ +-int32_t dotdot_get_time_dst_end( ++uint32_t dotdot_get_time_dst_end( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13097,7 +13097,7 @@ sl_status_t dotdot_set_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_dst_end ++ uint32_t new_dst_end + ); + + /** +@@ -13289,7 +13289,7 @@ bool dotdot_is_supported_time_standard_time ( + * + * @returns StandardTime attribute + */ +-int32_t dotdot_get_time_standard_time( ++uint32_t dotdot_get_time_standard_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13309,7 +13309,7 @@ sl_status_t dotdot_set_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_standard_time ++ uint32_t new_standard_time + ); + + /** +@@ -13395,7 +13395,7 @@ bool dotdot_is_supported_time_local_time ( + * + * @returns LocalTime attribute + */ +-int32_t dotdot_get_time_local_time( ++uint32_t dotdot_get_time_local_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13415,7 +13415,7 @@ sl_status_t dotdot_set_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_local_time ++ uint32_t new_local_time + ); + + /** +@@ -13501,7 +13501,7 @@ bool dotdot_is_supported_time_last_set_time ( + * + * @returns LastSetTime attribute + */ +-uint8_t dotdot_get_time_last_set_time( ++uint32_t dotdot_get_time_last_set_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13521,7 +13521,7 @@ sl_status_t dotdot_set_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_last_set_time ++ uint32_t new_last_set_time + ); + + /** +@@ -13607,7 +13607,7 @@ bool dotdot_is_supported_time_valid_until_time ( + * + * @returns ValidUntilTime attribute + */ +-uint8_t dotdot_get_time_valid_until_time( ++uint32_t dotdot_get_time_valid_until_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13627,7 +13627,7 @@ sl_status_t dotdot_set_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_valid_until_time ++ uint32_t new_valid_until_time + ); + + /** +@@ -13741,7 +13741,7 @@ bool dotdot_is_supported_poll_control_check_in_interval ( + * + * @returns CheckInInterval attribute + */ +-int32_t dotdot_get_poll_control_check_in_interval( ++uint32_t dotdot_get_poll_control_check_in_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13761,7 +13761,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_check_in_interval ++ uint32_t new_check_in_interval + ); + + /** +@@ -13847,7 +13847,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval ( + * + * @returns LongPollInterval attribute + */ +-int32_t dotdot_get_poll_control_long_poll_interval( ++uint32_t dotdot_get_poll_control_long_poll_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13867,7 +13867,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_long_poll_interval ++ uint32_t new_long_poll_interval + ); + + /** +@@ -13953,7 +13953,7 @@ bool dotdot_is_supported_poll_control_short_poll_interval ( + * + * @returns ShortPollInterval attribute + */ +-int16_t dotdot_get_poll_control_short_poll_interval( ++uint16_t dotdot_get_poll_control_short_poll_interval( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -13973,7 +13973,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_short_poll_interval ++ uint16_t new_short_poll_interval + ); + + /** +@@ -14059,7 +14059,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout ( + * + * @returns FastPollTimeout attribute + */ +-int16_t dotdot_get_poll_control_fast_poll_timeout( ++uint16_t dotdot_get_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14079,7 +14079,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_fast_poll_timeout ++ uint16_t new_fast_poll_timeout + ); + + /** +@@ -14165,7 +14165,7 @@ bool dotdot_is_supported_poll_control_check_in_interval_min ( + * + * @returns CheckInIntervalMin attribute + */ +-int32_t dotdot_get_poll_control_check_in_interval_min( ++uint32_t dotdot_get_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14185,7 +14185,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_check_in_interval_min ++ uint32_t new_check_in_interval_min + ); + + /** +@@ -14271,7 +14271,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval_min ( + * + * @returns LongPollIntervalMin attribute + */ +-int32_t dotdot_get_poll_control_long_poll_interval_min( ++uint32_t dotdot_get_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14291,7 +14291,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_long_poll_interval_min ++ uint32_t new_long_poll_interval_min + ); + + /** +@@ -14377,7 +14377,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout_max ( + * + * @returns FastPollTimeoutMax attribute + */ +-int16_t dotdot_get_poll_control_fast_poll_timeout_max( ++uint16_t dotdot_get_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14397,7 +14397,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_fast_poll_timeout_max ++ uint16_t new_fast_poll_timeout_max + ); + + /** +@@ -14511,7 +14511,7 @@ bool dotdot_is_supported_shade_configuration_physical_closed_limit ( + * + * @returns PhysicalClosedLimit attribute + */ +-int16_t dotdot_get_shade_configuration_physical_closed_limit( ++uint16_t dotdot_get_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14531,7 +14531,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit ++ uint16_t new_physical_closed_limit + ); + + /** +@@ -14617,7 +14617,7 @@ bool dotdot_is_supported_shade_configuration_motor_step_size ( + * + * @returns MotorStepSize attribute + */ +-int8_t dotdot_get_shade_configuration_motor_step_size( ++uint8_t dotdot_get_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14637,7 +14637,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_motor_step_size ++ uint8_t new_motor_step_size + ); + + /** +@@ -14829,7 +14829,7 @@ bool dotdot_is_supported_shade_configuration_closed_limit ( + * + * @returns ClosedLimit attribute + */ +-int16_t dotdot_get_shade_configuration_closed_limit( ++uint16_t dotdot_get_shade_configuration_closed_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -14849,7 +14849,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_closed_limit ++ uint16_t new_closed_limit + ); + + /** +@@ -15493,7 +15493,7 @@ bool dotdot_is_supported_door_lock_door_open_events ( + * + * @returns DoorOpenEvents attribute + */ +-int32_t dotdot_get_door_lock_door_open_events( ++uint32_t dotdot_get_door_lock_door_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15513,7 +15513,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_door_open_events ++ uint32_t new_door_open_events + ); + + /** +@@ -15599,7 +15599,7 @@ bool dotdot_is_supported_door_lock_door_closed_events ( + * + * @returns DoorClosedEvents attribute + */ +-int32_t dotdot_get_door_lock_door_closed_events( ++uint32_t dotdot_get_door_lock_door_closed_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15619,7 +15619,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_door_closed_events ++ uint32_t new_door_closed_events + ); + + /** +@@ -15705,7 +15705,7 @@ bool dotdot_is_supported_door_lock_open_period ( + * + * @returns OpenPeriod attribute + */ +-int16_t dotdot_get_door_lock_open_period( ++uint16_t dotdot_get_door_lock_open_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15725,7 +15725,7 @@ sl_status_t dotdot_set_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_period ++ uint16_t new_open_period + ); + + /** +@@ -15811,7 +15811,7 @@ bool dotdot_is_supported_door_lock_number_of_log_records_supported ( + * + * @returns NumberOfLogRecordsSupported attribute + */ +-int16_t dotdot_get_door_lock_number_of_log_records_supported( ++uint16_t dotdot_get_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15831,7 +15831,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_log_records_supported ++ uint16_t new_number_of_log_records_supported + ); + + /** +@@ -15917,7 +15917,7 @@ bool dotdot_is_supported_door_lock_number_of_total_users_supported ( + * + * @returns NumberOfTotalUsersSupported attribute + */ +-int16_t dotdot_get_door_lock_number_of_total_users_supported( ++uint16_t dotdot_get_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -15937,7 +15937,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_total_users_supported ++ uint16_t new_number_of_total_users_supported + ); + + /** +@@ -16023,7 +16023,7 @@ bool dotdot_is_supported_door_lock_number_of_pin_users_supported ( + * + * @returns NumberOfPINUsersSupported attribute + */ +-int16_t dotdot_get_door_lock_number_of_pin_users_supported( ++uint16_t dotdot_get_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16043,7 +16043,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_pin_users_supported ++ uint16_t new_number_of_pin_users_supported + ); + + /** +@@ -16129,7 +16129,7 @@ bool dotdot_is_supported_door_lock_number_of_rfid_users_supported ( + * + * @returns NumberOfRFIDUsersSupported attribute + */ +-int16_t dotdot_get_door_lock_number_of_rfid_users_supported( ++uint16_t dotdot_get_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16149,7 +16149,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_rfid_users_supported ++ uint16_t new_number_of_rfid_users_supported + ); + + /** +@@ -16235,7 +16235,7 @@ bool dotdot_is_supported_door_lock_number_of_week_day_schedules_supported_per_us + * + * @returns NumberOfWeekDaySchedulesSupportedPerUser attribute + */ +-int8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16255,7 +16255,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_week_day_schedules_supported_per_user ++ uint8_t new_number_of_week_day_schedules_supported_per_user + ); + + /** +@@ -16341,7 +16341,7 @@ bool dotdot_is_supported_door_lock_number_of_year_day_schedules_supported_per_us + * + * @returns NumberOfYearDaySchedulesSupportedPerUser attribute + */ +-int8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16361,7 +16361,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_year_day_schedules_supported_per_user ++ uint8_t new_number_of_year_day_schedules_supported_per_user + ); + + /** +@@ -16447,7 +16447,7 @@ bool dotdot_is_supported_door_lock_number_of_holiday_schedules_supported ( + * + * @returns NumberOfHolidaySchedulesSupported attribute + */ +-int8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( ++uint8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16467,7 +16467,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_holiday_schedules_supported ++ uint8_t new_number_of_holiday_schedules_supported + ); + + /** +@@ -16553,7 +16553,7 @@ bool dotdot_is_supported_door_lock_max_pin_code_length ( + * + * @returns MaxPINCodeLength attribute + */ +-int8_t dotdot_get_door_lock_max_pin_code_length( ++uint8_t dotdot_get_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16573,7 +16573,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_pin_code_length ++ uint8_t new_max_pin_code_length + ); + + /** +@@ -16659,7 +16659,7 @@ bool dotdot_is_supported_door_lock_min_pin_code_length ( + * + * @returns MinPINCodeLength attribute + */ +-int8_t dotdot_get_door_lock_min_pin_code_length( ++uint8_t dotdot_get_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16679,7 +16679,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_pin_code_length ++ uint8_t new_min_pin_code_length + ); + + /** +@@ -16765,7 +16765,7 @@ bool dotdot_is_supported_door_lock_max_rfid_code_length ( + * + * @returns MaxRFIDCodeLength attribute + */ +-int8_t dotdot_get_door_lock_max_rfid_code_length( ++uint8_t dotdot_get_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16785,7 +16785,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_rfid_code_length ++ uint8_t new_max_rfid_code_length + ); + + /** +@@ -16871,7 +16871,7 @@ bool dotdot_is_supported_door_lock_min_rfid_code_length ( + * + * @returns MinRFIDCodeLength attribute + */ +-int8_t dotdot_get_door_lock_min_rfid_code_length( ++uint8_t dotdot_get_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -16891,7 +16891,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_rfid_code_length ++ uint8_t new_min_rfid_code_length + ); + + /** +@@ -17083,7 +17083,7 @@ bool dotdot_is_supported_door_lock_number_of_credentials_supported_per_user ( + * + * @returns NumberOfCredentialsSupportedPerUser attribute + */ +-int8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17103,7 +17103,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_credentials_supported_per_user ++ uint8_t new_number_of_credentials_supported_per_user + ); + + /** +@@ -17404,7 +17404,7 @@ bool dotdot_is_supported_door_lock_led_settings ( + * + * @returns LEDSettings attribute + */ +-int8_t dotdot_get_door_lock_led_settings( ++uint8_t dotdot_get_door_lock_led_settings( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17424,7 +17424,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_led_settings ++ uint8_t new_led_settings + ); + + /** +@@ -17510,7 +17510,7 @@ bool dotdot_is_supported_door_lock_auto_relock_time ( + * + * @returns AutoRelockTime attribute + */ +-int32_t dotdot_get_door_lock_auto_relock_time( ++uint32_t dotdot_get_door_lock_auto_relock_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17530,7 +17530,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_auto_relock_time ++ uint32_t new_auto_relock_time + ); + + /** +@@ -17616,7 +17616,7 @@ bool dotdot_is_supported_door_lock_sound_volume ( + * + * @returns SoundVolume attribute + */ +-int8_t dotdot_get_door_lock_sound_volume( ++uint8_t dotdot_get_door_lock_sound_volume( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -17636,7 +17636,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_sound_volume ++ uint8_t new_sound_volume + ); + + /** +@@ -18570,7 +18570,7 @@ bool dotdot_is_supported_door_lock_wrong_code_entry_limit ( + * + * @returns WrongCodeEntryLimit attribute + */ +-int8_t dotdot_get_door_lock_wrong_code_entry_limit( ++uint8_t dotdot_get_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -18590,7 +18590,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_wrong_code_entry_limit ++ uint8_t new_wrong_code_entry_limit + ); + + /** +@@ -18676,7 +18676,7 @@ bool dotdot_is_supported_door_lock_user_code_temporary_disable_time ( + * + * @returns UserCodeTemporaryDisableTime attribute + */ +-int8_t dotdot_get_door_lock_user_code_temporary_disable_time( ++uint8_t dotdot_get_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -18696,7 +18696,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_user_code_temporary_disable_time ++ uint8_t new_user_code_temporary_disable_time + ); + + /** +@@ -19100,7 +19100,7 @@ bool dotdot_is_supported_door_lock_expiring_user_timeout ( + * + * @returns ExpiringUserTimeout attribute + */ +-int16_t dotdot_get_door_lock_expiring_user_timeout( ++uint16_t dotdot_get_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -19120,7 +19120,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_expiring_user_timeout ++ uint16_t new_expiring_user_timeout + ); + + /** +@@ -20294,7 +20294,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_lift ( + * + * @returns PhysicalClosedLimitLift attribute + */ +-int16_t dotdot_get_window_covering_physical_closed_limit_lift( ++uint16_t dotdot_get_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20314,7 +20314,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit_lift ++ uint16_t new_physical_closed_limit_lift + ); + + /** +@@ -20400,7 +20400,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_tilt ( + * + * @returns PhysicalClosedLimitTilt attribute + */ +-int16_t dotdot_get_window_covering_physical_closed_limit_tilt( ++uint16_t dotdot_get_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20420,7 +20420,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit_tilt ++ uint16_t new_physical_closed_limit_tilt + ); + + /** +@@ -20506,7 +20506,7 @@ bool dotdot_is_supported_window_covering_current_position_lift ( + * + * @returns CurrentPositionLift attribute + */ +-int16_t dotdot_get_window_covering_current_position_lift( ++uint16_t dotdot_get_window_covering_current_position_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20526,7 +20526,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_position_lift ++ uint16_t new_current_position_lift + ); + + /** +@@ -20612,7 +20612,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt ( + * + * @returns CurrentPositionTilt attribute + */ +-int16_t dotdot_get_window_covering_current_position_tilt( ++uint16_t dotdot_get_window_covering_current_position_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20632,7 +20632,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_position_tilt ++ uint16_t new_current_position_tilt + ); + + /** +@@ -20718,7 +20718,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_lift ( + * + * @returns NumberOfActuationsLift attribute + */ +-int16_t dotdot_get_window_covering_number_of_actuations_lift( ++uint16_t dotdot_get_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20738,7 +20738,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_actuations_lift ++ uint16_t new_number_of_actuations_lift + ); + + /** +@@ -20824,7 +20824,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_tilt ( + * + * @returns NumberOfActuationsTilt attribute + */ +-int16_t dotdot_get_window_covering_number_of_actuations_tilt( ++uint16_t dotdot_get_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -20844,7 +20844,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_actuations_tilt ++ uint16_t new_number_of_actuations_tilt + ); + + /** +@@ -21036,7 +21036,7 @@ bool dotdot_is_supported_window_covering_current_position_lift_percentage ( + * + * @returns CurrentPositionLiftPercentage attribute + */ +-int8_t dotdot_get_window_covering_current_position_lift_percentage( ++uint8_t dotdot_get_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21056,7 +21056,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_position_lift_percentage ++ uint8_t new_current_position_lift_percentage + ); + + /** +@@ -21142,7 +21142,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt_percentage ( + * + * @returns CurrentPositionTiltPercentage attribute + */ +-int8_t dotdot_get_window_covering_current_position_tilt_percentage( ++uint8_t dotdot_get_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21162,7 +21162,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_position_tilt_percentage ++ uint8_t new_current_position_tilt_percentage + ); + + /** +@@ -21248,7 +21248,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_lift ( + * + * @returns InstalledOpenLimitLift attribute + */ +-int16_t dotdot_get_window_covering_installed_open_limit_lift( ++uint16_t dotdot_get_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21268,7 +21268,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_open_limit_lift ++ uint16_t new_installed_open_limit_lift + ); + + /** +@@ -21354,7 +21354,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_lift ( + * + * @returns InstalledClosedLimitLift attribute + */ +-int16_t dotdot_get_window_covering_installed_closed_limit_lift( ++uint16_t dotdot_get_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21374,7 +21374,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_closed_limit_lift ++ uint16_t new_installed_closed_limit_lift + ); + + /** +@@ -21460,7 +21460,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_tilt ( + * + * @returns InstalledOpenLimitTilt attribute + */ +-int16_t dotdot_get_window_covering_installed_open_limit_tilt( ++uint16_t dotdot_get_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21480,7 +21480,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_open_limit_tilt ++ uint16_t new_installed_open_limit_tilt + ); + + /** +@@ -21566,7 +21566,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_tilt ( + * + * @returns InstalledClosedLimitTilt attribute + */ +-int16_t dotdot_get_window_covering_installed_closed_limit_tilt( ++uint16_t dotdot_get_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21586,7 +21586,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_closed_limit_tilt ++ uint16_t new_installed_closed_limit_tilt + ); + + /** +@@ -21672,7 +21672,7 @@ bool dotdot_is_supported_window_covering_velocity_lift ( + * + * @returns VelocityLift attribute + */ +-int16_t dotdot_get_window_covering_velocity_lift( ++uint16_t dotdot_get_window_covering_velocity_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21692,7 +21692,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_velocity_lift ++ uint16_t new_velocity_lift + ); + + /** +@@ -21778,7 +21778,7 @@ bool dotdot_is_supported_window_covering_acceleration_time_lift ( + * + * @returns AccelerationTimeLift attribute + */ +-int16_t dotdot_get_window_covering_acceleration_time_lift( ++uint16_t dotdot_get_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21798,7 +21798,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_acceleration_time_lift ++ uint16_t new_acceleration_time_lift + ); + + /** +@@ -21884,7 +21884,7 @@ bool dotdot_is_supported_window_covering_deceleration_time_lift ( + * + * @returns DecelerationTimeLift attribute + */ +-int16_t dotdot_get_window_covering_deceleration_time_lift( ++uint16_t dotdot_get_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -21904,7 +21904,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_deceleration_time_lift ++ uint16_t new_deceleration_time_lift + ); + + /** +@@ -22099,7 +22099,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_lift ( + * + * @returns IntermediateSetpointsLift attribute + */ +-uint8_t dotdot_get_window_covering_intermediate_setpoints_lift( ++const char* dotdot_get_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22119,7 +22119,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intermediate_setpoints_lift ++ const char* new_intermediate_setpoints_lift + ); + + /** +@@ -22208,7 +22208,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_tilt ( + * + * @returns IntermediateSetpointsTilt attribute + */ +-uint8_t dotdot_get_window_covering_intermediate_setpoints_tilt( ++const char* dotdot_get_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22228,7 +22228,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intermediate_setpoints_tilt ++ const char* new_intermediate_setpoints_tilt + ); + + /** +@@ -22660,7 +22660,7 @@ bool dotdot_is_supported_barrier_control_open_events ( + * + * @returns OpenEvents attribute + */ +-int16_t dotdot_get_barrier_control_open_events( ++uint16_t dotdot_get_barrier_control_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22680,7 +22680,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_events ++ uint16_t new_open_events + ); + + /** +@@ -22766,7 +22766,7 @@ bool dotdot_is_supported_barrier_control_close_events ( + * + * @returns CloseEvents attribute + */ +-int16_t dotdot_get_barrier_control_close_events( ++uint16_t dotdot_get_barrier_control_close_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22786,7 +22786,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_close_events ++ uint16_t new_close_events + ); + + /** +@@ -22872,7 +22872,7 @@ bool dotdot_is_supported_barrier_control_command_open_events ( + * + * @returns CommandOpenEvents attribute + */ +-int16_t dotdot_get_barrier_control_command_open_events( ++uint16_t dotdot_get_barrier_control_command_open_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22892,7 +22892,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_command_open_events ++ uint16_t new_command_open_events + ); + + /** +@@ -22978,7 +22978,7 @@ bool dotdot_is_supported_barrier_control_command_close_events ( + * + * @returns CommandCloseEvents attribute + */ +-int16_t dotdot_get_barrier_control_command_close_events( ++uint16_t dotdot_get_barrier_control_command_close_events( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -22998,7 +22998,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_command_close_events ++ uint16_t new_command_close_events + ); + + /** +@@ -23084,7 +23084,7 @@ bool dotdot_is_supported_barrier_control_open_period ( + * + * @returns OpenPeriod attribute + */ +-int16_t dotdot_get_barrier_control_open_period( ++uint16_t dotdot_get_barrier_control_open_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23104,7 +23104,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_period ++ uint16_t new_open_period + ); + + /** +@@ -23190,7 +23190,7 @@ bool dotdot_is_supported_barrier_control_close_period ( + * + * @returns ClosePeriod attribute + */ +-int16_t dotdot_get_barrier_control_close_period( ++uint16_t dotdot_get_barrier_control_close_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23210,7 +23210,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_close_period ++ uint16_t new_close_period + ); + + /** +@@ -23296,7 +23296,7 @@ bool dotdot_is_supported_barrier_control_barrier_position ( + * + * @returns BarrierPosition attribute + */ +-int8_t dotdot_get_barrier_control_barrier_position( ++uint8_t dotdot_get_barrier_control_barrier_position( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23316,7 +23316,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_barrier_position ++ uint8_t new_barrier_position + ); + + /** +@@ -23536,7 +23536,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_speed ( + * + * @returns MaxSpeed attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_max_speed( ++uint16_t dotdot_get_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23556,7 +23556,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_speed ++ uint16_t new_max_speed + ); + + /** +@@ -23642,7 +23642,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_flow ( + * + * @returns MaxFlow attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_max_flow( ++uint16_t dotdot_get_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -23662,7 +23662,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_flow ++ uint16_t new_max_flow + ); + + /** +@@ -24172,7 +24172,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_speed ( + * + * @returns MinConstSpeed attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_min_const_speed( ++uint16_t dotdot_get_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24192,7 +24192,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_const_speed ++ uint16_t new_min_const_speed + ); + + /** +@@ -24278,7 +24278,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_speed ( + * + * @returns MaxConstSpeed attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_max_const_speed( ++uint16_t dotdot_get_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24298,7 +24298,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_const_speed ++ uint16_t new_max_const_speed + ); + + /** +@@ -24384,7 +24384,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_flow ( + * + * @returns MinConstFlow attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_min_const_flow( ++uint16_t dotdot_get_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24404,7 +24404,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_const_flow ++ uint16_t new_min_const_flow + ); + + /** +@@ -24490,7 +24490,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_flow ( + * + * @returns MaxConstFlow attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_max_const_flow( ++uint16_t dotdot_get_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -24510,7 +24510,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_const_flow ++ uint16_t new_max_const_flow + ); + + /** +@@ -25232,7 +25232,7 @@ bool dotdot_is_supported_pump_configuration_and_control_speed ( + * + * @returns Speed attribute + */ +-int16_t dotdot_get_pump_configuration_and_control_speed( ++uint16_t dotdot_get_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25252,7 +25252,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_speed ++ uint16_t new_speed + ); + + /** +@@ -25338,7 +25338,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_running_hours ( + * + * @returns LifetimeRunningHours attribute + */ +-int32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( ++uint32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25358,7 +25358,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lifetime_running_hours ++ uint32_t new_lifetime_running_hours + ); + + /** +@@ -25444,7 +25444,7 @@ bool dotdot_is_supported_pump_configuration_and_control_power ( + * + * @returns Power attribute + */ +-int32_t dotdot_get_pump_configuration_and_control_power( ++uint32_t dotdot_get_pump_configuration_and_control_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25464,7 +25464,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power ++ uint32_t new_power + ); + + /** +@@ -25550,7 +25550,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_energy_consumed + * + * @returns LifetimeEnergyConsumed attribute + */ +-int32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( ++uint32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -25570,7 +25570,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lifetime_energy_consumed ++ uint32_t new_lifetime_energy_consumed + ); + + /** +@@ -26744,7 +26744,7 @@ bool dotdot_is_supported_thermostat_pi_cooling_demand ( + * + * @returns PICoolingDemand attribute + */ +-int8_t dotdot_get_thermostat_pi_cooling_demand( ++uint8_t dotdot_get_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -26764,7 +26764,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pi_cooling_demand ++ uint8_t new_pi_cooling_demand + ); + + /** +@@ -26850,7 +26850,7 @@ bool dotdot_is_supported_thermostat_pi_heating_demand ( + * + * @returns PIHeatingDemand attribute + */ +-int8_t dotdot_get_thermostat_pi_heating_demand( ++uint8_t dotdot_get_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -26870,7 +26870,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pi_heating_demand ++ uint8_t new_pi_heating_demand + ); + + /** +@@ -28758,7 +28758,7 @@ bool dotdot_is_supported_thermostat_number_of_weekly_transitions ( + * + * @returns NumberOfWeeklyTransitions attribute + */ +-int8_t dotdot_get_thermostat_number_of_weekly_transitions( ++uint8_t dotdot_get_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -28778,7 +28778,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_weekly_transitions ++ uint8_t new_number_of_weekly_transitions + ); + + /** +@@ -28864,7 +28864,7 @@ bool dotdot_is_supported_thermostat_number_of_daily_transitions ( + * + * @returns NumberOfDailyTransitions attribute + */ +-int8_t dotdot_get_thermostat_number_of_daily_transitions( ++uint8_t dotdot_get_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -28884,7 +28884,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_daily_transitions ++ uint8_t new_number_of_daily_transitions + ); + + /** +@@ -29076,7 +29076,7 @@ bool dotdot_is_supported_thermostat_temperature_setpoint_hold_duration ( + * + * @returns TemperatureSetpointHoldDuration attribute + */ +-int16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( ++uint16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29096,7 +29096,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_temperature_setpoint_hold_duration ++ uint16_t new_temperature_setpoint_hold_duration + ); + + /** +@@ -29606,7 +29606,7 @@ bool dotdot_is_supported_thermostat_setpoint_change_source_timestamp ( + * + * @returns SetpointChangeSourceTimestamp attribute + */ +-uint8_t dotdot_get_thermostat_setpoint_change_source_timestamp( ++uint32_t dotdot_get_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29626,7 +29626,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_setpoint_change_source_timestamp ++ uint32_t new_setpoint_change_source_timestamp + ); + + /** +@@ -29712,7 +29712,7 @@ bool dotdot_is_supported_thermostat_occupied_setback ( + * + * @returns OccupiedSetback attribute + */ +-int8_t dotdot_get_thermostat_occupied_setback( ++uint8_t dotdot_get_thermostat_occupied_setback( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29732,7 +29732,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback ++ uint8_t new_occupied_setback + ); + + /** +@@ -29818,7 +29818,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_min ( + * + * @returns OccupiedSetbackMin attribute + */ +-int8_t dotdot_get_thermostat_occupied_setback_min( ++uint8_t dotdot_get_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29838,7 +29838,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback_min ++ uint8_t new_occupied_setback_min + ); + + /** +@@ -29924,7 +29924,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_max ( + * + * @returns OccupiedSetbackMax attribute + */ +-int8_t dotdot_get_thermostat_occupied_setback_max( ++uint8_t dotdot_get_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -29944,7 +29944,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback_max ++ uint8_t new_occupied_setback_max + ); + + /** +@@ -30030,7 +30030,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback ( + * + * @returns UnoccupiedSetback attribute + */ +-int8_t dotdot_get_thermostat_unoccupied_setback( ++uint8_t dotdot_get_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30050,7 +30050,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback ++ uint8_t new_unoccupied_setback + ); + + /** +@@ -30136,7 +30136,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_min ( + * + * @returns UnoccupiedSetbackMin attribute + */ +-int8_t dotdot_get_thermostat_unoccupied_setback_min( ++uint8_t dotdot_get_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30156,7 +30156,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback_min ++ uint8_t new_unoccupied_setback_min + ); + + /** +@@ -30242,7 +30242,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_max ( + * + * @returns UnoccupiedSetbackMax attribute + */ +-int8_t dotdot_get_thermostat_unoccupied_setback_max( ++uint8_t dotdot_get_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30262,7 +30262,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback_max ++ uint8_t new_unoccupied_setback_max + ); + + /** +@@ -30348,7 +30348,7 @@ bool dotdot_is_supported_thermostat_emergency_heat_delta ( + * + * @returns EmergencyHeatDelta attribute + */ +-int8_t dotdot_get_thermostat_emergency_heat_delta( ++uint8_t dotdot_get_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30368,7 +30368,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_emergency_heat_delta ++ uint8_t new_emergency_heat_delta + ); + + /** +@@ -30560,7 +30560,7 @@ bool dotdot_is_supported_thermostat_ac_capacity ( + * + * @returns ACCapacity attribute + */ +-int16_t dotdot_get_thermostat_ac_capacity( ++uint16_t dotdot_get_thermostat_ac_capacity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -30580,7 +30580,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_capacity ++ uint16_t new_ac_capacity + ); + + /** +@@ -31570,7 +31570,7 @@ bool dotdot_is_supported_dehumidification_control_relative_humidity ( + * + * @returns RelativeHumidity attribute + */ +-int8_t dotdot_get_dehumidification_control_relative_humidity( ++uint8_t dotdot_get_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31590,7 +31590,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_relative_humidity ++ uint8_t new_relative_humidity + ); + + /** +@@ -31676,7 +31676,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_cooling ( + * + * @returns DehumidificationCooling attribute + */ +-int8_t dotdot_get_dehumidification_control_dehumidification_cooling( ++uint8_t dotdot_get_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31696,7 +31696,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_cooling ++ uint8_t new_dehumidification_cooling + ); + + /** +@@ -31782,7 +31782,7 @@ bool dotdot_is_supported_dehumidification_control_rh_dehumidification_setpoint ( + * + * @returns RHDehumidificationSetpoint attribute + */ +-int8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( ++uint8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -31802,7 +31802,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_rh_dehumidification_setpoint ++ uint8_t new_rh_dehumidification_setpoint + ); + + /** +@@ -32100,7 +32100,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_hysteresis ( + * + * @returns DehumidificationHysteresis attribute + */ +-int8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( ++uint8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32120,7 +32120,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_hysteresis ++ uint8_t new_dehumidification_hysteresis + ); + + /** +@@ -32206,7 +32206,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_max_cool ( + * + * @returns DehumidificationMaxCool attribute + */ +-int8_t dotdot_get_dehumidification_control_dehumidification_max_cool( ++uint8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32226,7 +32226,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_max_cool ++ uint8_t new_dehumidification_max_cool + ); + + /** +@@ -32792,7 +32792,7 @@ bool dotdot_is_supported_color_control_current_hue ( + * + * @returns CurrentHue attribute + */ +-int8_t dotdot_get_color_control_current_hue( ++uint8_t dotdot_get_color_control_current_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32812,7 +32812,7 @@ sl_status_t dotdot_set_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_hue ++ uint8_t new_current_hue + ); + + /** +@@ -32898,7 +32898,7 @@ bool dotdot_is_supported_color_control_current_saturation ( + * + * @returns CurrentSaturation attribute + */ +-int8_t dotdot_get_color_control_current_saturation( ++uint8_t dotdot_get_color_control_current_saturation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -32918,7 +32918,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_saturation ++ uint8_t new_current_saturation + ); + + /** +@@ -33004,7 +33004,7 @@ bool dotdot_is_supported_color_control_remaining_time ( + * + * @returns RemainingTime attribute + */ +-int16_t dotdot_get_color_control_remaining_time( ++uint16_t dotdot_get_color_control_remaining_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33024,7 +33024,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_remaining_time ++ uint16_t new_remaining_time + ); + + /** +@@ -33110,7 +33110,7 @@ bool dotdot_is_supported_color_control_currentx ( + * + * @returns CurrentX attribute + */ +-int16_t dotdot_get_color_control_currentx( ++uint16_t dotdot_get_color_control_currentx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33130,7 +33130,7 @@ sl_status_t dotdot_set_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_currentx ++ uint16_t new_currentx + ); + + /** +@@ -33216,7 +33216,7 @@ bool dotdot_is_supported_color_control_currenty ( + * + * @returns CurrentY attribute + */ +-int16_t dotdot_get_color_control_currenty( ++uint16_t dotdot_get_color_control_currenty( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33236,7 +33236,7 @@ sl_status_t dotdot_set_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_currenty ++ uint16_t new_currenty + ); + + /** +@@ -33537,7 +33537,7 @@ bool dotdot_is_supported_color_control_color_temperature_mireds ( + * + * @returns ColorTemperatureMireds attribute + */ +-int16_t dotdot_get_color_control_color_temperature_mireds( ++uint16_t dotdot_get_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33557,7 +33557,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temperature_mireds ++ uint16_t new_color_temperature_mireds + ); + + /** +@@ -33855,7 +33855,7 @@ bool dotdot_is_supported_color_control_number_of_primaries ( + * + * @returns NumberOfPrimaries attribute + */ +-int8_t dotdot_get_color_control_number_of_primaries( ++uint8_t dotdot_get_color_control_number_of_primaries( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33875,7 +33875,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_primaries ++ uint8_t new_number_of_primaries + ); + + /** +@@ -33961,7 +33961,7 @@ bool dotdot_is_supported_color_control_primary1x ( + * + * @returns Primary1X attribute + */ +-int16_t dotdot_get_color_control_primary1x( ++uint16_t dotdot_get_color_control_primary1x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -33981,7 +33981,7 @@ sl_status_t dotdot_set_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary1x ++ uint16_t new_primary1x + ); + + /** +@@ -34067,7 +34067,7 @@ bool dotdot_is_supported_color_control_primary1y ( + * + * @returns Primary1Y attribute + */ +-int16_t dotdot_get_color_control_primary1y( ++uint16_t dotdot_get_color_control_primary1y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34087,7 +34087,7 @@ sl_status_t dotdot_set_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary1y ++ uint16_t new_primary1y + ); + + /** +@@ -34173,7 +34173,7 @@ bool dotdot_is_supported_color_control_primary1_intensity ( + * + * @returns Primary1Intensity attribute + */ +-int8_t dotdot_get_color_control_primary1_intensity( ++uint8_t dotdot_get_color_control_primary1_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34193,7 +34193,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary1_intensity ++ uint8_t new_primary1_intensity + ); + + /** +@@ -34279,7 +34279,7 @@ bool dotdot_is_supported_color_control_primary2x ( + * + * @returns Primary2X attribute + */ +-int16_t dotdot_get_color_control_primary2x( ++uint16_t dotdot_get_color_control_primary2x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34299,7 +34299,7 @@ sl_status_t dotdot_set_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary2x ++ uint16_t new_primary2x + ); + + /** +@@ -34385,7 +34385,7 @@ bool dotdot_is_supported_color_control_primary2y ( + * + * @returns Primary2Y attribute + */ +-int16_t dotdot_get_color_control_primary2y( ++uint16_t dotdot_get_color_control_primary2y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34405,7 +34405,7 @@ sl_status_t dotdot_set_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary2y ++ uint16_t new_primary2y + ); + + /** +@@ -34491,7 +34491,7 @@ bool dotdot_is_supported_color_control_primary2_intensity ( + * + * @returns Primary2Intensity attribute + */ +-int8_t dotdot_get_color_control_primary2_intensity( ++uint8_t dotdot_get_color_control_primary2_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34511,7 +34511,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary2_intensity ++ uint8_t new_primary2_intensity + ); + + /** +@@ -34597,7 +34597,7 @@ bool dotdot_is_supported_color_control_primary3x ( + * + * @returns Primary3X attribute + */ +-int16_t dotdot_get_color_control_primary3x( ++uint16_t dotdot_get_color_control_primary3x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34617,7 +34617,7 @@ sl_status_t dotdot_set_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary3x ++ uint16_t new_primary3x + ); + + /** +@@ -34703,7 +34703,7 @@ bool dotdot_is_supported_color_control_primary3y ( + * + * @returns Primary3Y attribute + */ +-int16_t dotdot_get_color_control_primary3y( ++uint16_t dotdot_get_color_control_primary3y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34723,7 +34723,7 @@ sl_status_t dotdot_set_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary3y ++ uint16_t new_primary3y + ); + + /** +@@ -34809,7 +34809,7 @@ bool dotdot_is_supported_color_control_primary3_intensity ( + * + * @returns Primary3Intensity attribute + */ +-int8_t dotdot_get_color_control_primary3_intensity( ++uint8_t dotdot_get_color_control_primary3_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34829,7 +34829,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary3_intensity ++ uint8_t new_primary3_intensity + ); + + /** +@@ -34915,7 +34915,7 @@ bool dotdot_is_supported_color_control_primary4x ( + * + * @returns Primary4X attribute + */ +-int16_t dotdot_get_color_control_primary4x( ++uint16_t dotdot_get_color_control_primary4x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -34935,7 +34935,7 @@ sl_status_t dotdot_set_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary4x ++ uint16_t new_primary4x + ); + + /** +@@ -35021,7 +35021,7 @@ bool dotdot_is_supported_color_control_primary4y ( + * + * @returns Primary4Y attribute + */ +-int16_t dotdot_get_color_control_primary4y( ++uint16_t dotdot_get_color_control_primary4y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35041,7 +35041,7 @@ sl_status_t dotdot_set_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary4y ++ uint16_t new_primary4y + ); + + /** +@@ -35127,7 +35127,7 @@ bool dotdot_is_supported_color_control_primary4_intensity ( + * + * @returns Primary4Intensity attribute + */ +-int8_t dotdot_get_color_control_primary4_intensity( ++uint8_t dotdot_get_color_control_primary4_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35147,7 +35147,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary4_intensity ++ uint8_t new_primary4_intensity + ); + + /** +@@ -35233,7 +35233,7 @@ bool dotdot_is_supported_color_control_primary5x ( + * + * @returns Primary5X attribute + */ +-int16_t dotdot_get_color_control_primary5x( ++uint16_t dotdot_get_color_control_primary5x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35253,7 +35253,7 @@ sl_status_t dotdot_set_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary5x ++ uint16_t new_primary5x + ); + + /** +@@ -35339,7 +35339,7 @@ bool dotdot_is_supported_color_control_primary5y ( + * + * @returns Primary5Y attribute + */ +-int16_t dotdot_get_color_control_primary5y( ++uint16_t dotdot_get_color_control_primary5y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35359,7 +35359,7 @@ sl_status_t dotdot_set_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary5y ++ uint16_t new_primary5y + ); + + /** +@@ -35445,7 +35445,7 @@ bool dotdot_is_supported_color_control_primary5_intensity ( + * + * @returns Primary5Intensity attribute + */ +-int8_t dotdot_get_color_control_primary5_intensity( ++uint8_t dotdot_get_color_control_primary5_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35465,7 +35465,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary5_intensity ++ uint8_t new_primary5_intensity + ); + + /** +@@ -35551,7 +35551,7 @@ bool dotdot_is_supported_color_control_primary6x ( + * + * @returns Primary6X attribute + */ +-int16_t dotdot_get_color_control_primary6x( ++uint16_t dotdot_get_color_control_primary6x( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35571,7 +35571,7 @@ sl_status_t dotdot_set_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary6x ++ uint16_t new_primary6x + ); + + /** +@@ -35657,7 +35657,7 @@ bool dotdot_is_supported_color_control_primary6y ( + * + * @returns Primary6Y attribute + */ +-int16_t dotdot_get_color_control_primary6y( ++uint16_t dotdot_get_color_control_primary6y( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35677,7 +35677,7 @@ sl_status_t dotdot_set_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary6y ++ uint16_t new_primary6y + ); + + /** +@@ -35763,7 +35763,7 @@ bool dotdot_is_supported_color_control_primary6_intensity ( + * + * @returns Primary6Intensity attribute + */ +-int8_t dotdot_get_color_control_primary6_intensity( ++uint8_t dotdot_get_color_control_primary6_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35783,7 +35783,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary6_intensity ++ uint8_t new_primary6_intensity + ); + + /** +@@ -35869,7 +35869,7 @@ bool dotdot_is_supported_color_control_white_pointx ( + * + * @returns WhitePointX attribute + */ +-int16_t dotdot_get_color_control_white_pointx( ++uint16_t dotdot_get_color_control_white_pointx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35889,7 +35889,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_white_pointx ++ uint16_t new_white_pointx + ); + + /** +@@ -35975,7 +35975,7 @@ bool dotdot_is_supported_color_control_white_pointy ( + * + * @returns WhitePointY attribute + */ +-int16_t dotdot_get_color_control_white_pointy( ++uint16_t dotdot_get_color_control_white_pointy( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -35995,7 +35995,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_white_pointy ++ uint16_t new_white_pointy + ); + + /** +@@ -36081,7 +36081,7 @@ bool dotdot_is_supported_color_control_color_pointrx ( + * + * @returns ColorPointRX attribute + */ +-int16_t dotdot_get_color_control_color_pointrx( ++uint16_t dotdot_get_color_control_color_pointrx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36101,7 +36101,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointrx ++ uint16_t new_color_pointrx + ); + + /** +@@ -36187,7 +36187,7 @@ bool dotdot_is_supported_color_control_color_pointry ( + * + * @returns ColorPointRY attribute + */ +-int16_t dotdot_get_color_control_color_pointry( ++uint16_t dotdot_get_color_control_color_pointry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36207,7 +36207,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointry ++ uint16_t new_color_pointry + ); + + /** +@@ -36293,7 +36293,7 @@ bool dotdot_is_supported_color_control_color_pointr_intensity ( + * + * @returns ColorPointRIntensity attribute + */ +-int8_t dotdot_get_color_control_color_pointr_intensity( ++uint8_t dotdot_get_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36313,7 +36313,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointr_intensity ++ uint8_t new_color_pointr_intensity + ); + + /** +@@ -36399,7 +36399,7 @@ bool dotdot_is_supported_color_control_color_pointgx ( + * + * @returns ColorPointGX attribute + */ +-int16_t dotdot_get_color_control_color_pointgx( ++uint16_t dotdot_get_color_control_color_pointgx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36419,7 +36419,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointgx ++ uint16_t new_color_pointgx + ); + + /** +@@ -36505,7 +36505,7 @@ bool dotdot_is_supported_color_control_color_pointgy ( + * + * @returns ColorPointGY attribute + */ +-int16_t dotdot_get_color_control_color_pointgy( ++uint16_t dotdot_get_color_control_color_pointgy( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36525,7 +36525,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointgy ++ uint16_t new_color_pointgy + ); + + /** +@@ -36611,7 +36611,7 @@ bool dotdot_is_supported_color_control_color_pointg_intensity ( + * + * @returns ColorPointGIntensity attribute + */ +-int8_t dotdot_get_color_control_color_pointg_intensity( ++uint8_t dotdot_get_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36631,7 +36631,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointg_intensity ++ uint8_t new_color_pointg_intensity + ); + + /** +@@ -36717,7 +36717,7 @@ bool dotdot_is_supported_color_control_color_pointbx ( + * + * @returns ColorPointBX attribute + */ +-int16_t dotdot_get_color_control_color_pointbx( ++uint16_t dotdot_get_color_control_color_pointbx( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36737,7 +36737,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointbx ++ uint16_t new_color_pointbx + ); + + /** +@@ -36823,7 +36823,7 @@ bool dotdot_is_supported_color_control_color_pointby ( + * + * @returns ColorPointBY attribute + */ +-int16_t dotdot_get_color_control_color_pointby( ++uint16_t dotdot_get_color_control_color_pointby( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36843,7 +36843,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointby ++ uint16_t new_color_pointby + ); + + /** +@@ -36929,7 +36929,7 @@ bool dotdot_is_supported_color_control_color_pointb_intensity ( + * + * @returns ColorPointBIntensity attribute + */ +-int8_t dotdot_get_color_control_color_pointb_intensity( ++uint8_t dotdot_get_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -36949,7 +36949,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointb_intensity ++ uint8_t new_color_pointb_intensity + ); + + /** +@@ -37035,7 +37035,7 @@ bool dotdot_is_supported_color_control_enhanced_current_hue ( + * + * @returns EnhancedCurrentHue attribute + */ +-int16_t dotdot_get_color_control_enhanced_current_hue( ++uint16_t dotdot_get_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37055,7 +37055,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_enhanced_current_hue ++ uint16_t new_enhanced_current_hue + ); + + /** +@@ -37247,7 +37247,7 @@ bool dotdot_is_supported_color_control_color_loop_active ( + * + * @returns ColorLoopActive attribute + */ +-int8_t dotdot_get_color_control_color_loop_active( ++uint8_t dotdot_get_color_control_color_loop_active( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37267,7 +37267,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_loop_active ++ uint8_t new_color_loop_active + ); + + /** +@@ -37353,7 +37353,7 @@ bool dotdot_is_supported_color_control_color_loop_direction ( + * + * @returns ColorLoopDirection attribute + */ +-int8_t dotdot_get_color_control_color_loop_direction( ++uint8_t dotdot_get_color_control_color_loop_direction( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37373,7 +37373,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_loop_direction ++ uint8_t new_color_loop_direction + ); + + /** +@@ -37459,7 +37459,7 @@ bool dotdot_is_supported_color_control_color_loop_time ( + * + * @returns ColorLoopTime attribute + */ +-int16_t dotdot_get_color_control_color_loop_time( ++uint16_t dotdot_get_color_control_color_loop_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37479,7 +37479,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_time ++ uint16_t new_color_loop_time + ); + + /** +@@ -37565,7 +37565,7 @@ bool dotdot_is_supported_color_control_color_loop_start_enhanced_hue ( + * + * @returns ColorLoopStartEnhancedHue attribute + */ +-int16_t dotdot_get_color_control_color_loop_start_enhanced_hue( ++uint16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37585,7 +37585,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_start_enhanced_hue ++ uint16_t new_color_loop_start_enhanced_hue + ); + + /** +@@ -37671,7 +37671,7 @@ bool dotdot_is_supported_color_control_color_loop_stored_enhanced_hue ( + * + * @returns ColorLoopStoredEnhancedHue attribute + */ +-int16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( ++uint16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37691,7 +37691,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_stored_enhanced_hue ++ uint16_t new_color_loop_stored_enhanced_hue + ); + + /** +@@ -37883,7 +37883,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_min_mireds ( + * + * @returns ColorTempPhysicalMinMireds attribute + */ +-int16_t dotdot_get_color_control_color_temp_physical_min_mireds( ++uint16_t dotdot_get_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -37903,7 +37903,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temp_physical_min_mireds ++ uint16_t new_color_temp_physical_min_mireds + ); + + /** +@@ -37989,7 +37989,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_max_mireds ( + * + * @returns ColorTempPhysicalMaxMireds attribute + */ +-int16_t dotdot_get_color_control_color_temp_physical_max_mireds( ++uint16_t dotdot_get_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38009,7 +38009,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temp_physical_max_mireds ++ uint16_t new_color_temp_physical_max_mireds + ); + + /** +@@ -38095,7 +38095,7 @@ bool dotdot_is_supported_color_control_couple_color_temp_to_level_min_mireds ( + * + * @returns CoupleColorTempToLevelMinMireds attribute + */ +-int16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( ++uint16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38115,7 +38115,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_couple_color_temp_to_level_min_mireds ++ uint16_t new_couple_color_temp_to_level_min_mireds + ); + + /** +@@ -38201,7 +38201,7 @@ bool dotdot_is_supported_color_control_start_up_color_temperature_mireds ( + * + * @returns StartUpColorTemperatureMireds attribute + */ +-int16_t dotdot_get_color_control_start_up_color_temperature_mireds( ++uint16_t dotdot_get_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38221,7 +38221,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_start_up_color_temperature_mireds ++ uint16_t new_start_up_color_temperature_mireds + ); + + /** +@@ -38335,7 +38335,7 @@ bool dotdot_is_supported_ballast_configuration_physical_min_level ( + * + * @returns PhysicalMinLevel attribute + */ +-int8_t dotdot_get_ballast_configuration_physical_min_level( ++uint8_t dotdot_get_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38355,7 +38355,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_min_level ++ uint8_t new_physical_min_level + ); + + /** +@@ -38441,7 +38441,7 @@ bool dotdot_is_supported_ballast_configuration_physical_max_level ( + * + * @returns PhysicalMaxLevel attribute + */ +-int8_t dotdot_get_ballast_configuration_physical_max_level( ++uint8_t dotdot_get_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38461,7 +38461,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_max_level ++ uint8_t new_physical_max_level + ); + + /** +@@ -38653,7 +38653,7 @@ bool dotdot_is_supported_ballast_configuration_min_level ( + * + * @returns MinLevel attribute + */ +-int8_t dotdot_get_ballast_configuration_min_level( ++uint8_t dotdot_get_ballast_configuration_min_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38673,7 +38673,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_level ++ uint8_t new_min_level + ); + + /** +@@ -38759,7 +38759,7 @@ bool dotdot_is_supported_ballast_configuration_max_level ( + * + * @returns MaxLevel attribute + */ +-int8_t dotdot_get_ballast_configuration_max_level( ++uint8_t dotdot_get_ballast_configuration_max_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38779,7 +38779,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_level ++ uint8_t new_max_level + ); + + /** +@@ -38865,7 +38865,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_level ( + * + * @returns PowerOnLevel attribute + */ +-int8_t dotdot_get_ballast_configuration_power_on_level( ++uint8_t dotdot_get_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38885,7 +38885,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_power_on_level ++ uint8_t new_power_on_level + ); + + /** +@@ -38971,7 +38971,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_fade_time ( + * + * @returns PowerOnFadeTime attribute + */ +-int16_t dotdot_get_ballast_configuration_power_on_fade_time( ++uint16_t dotdot_get_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -38991,7 +38991,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_power_on_fade_time ++ uint16_t new_power_on_fade_time + ); + + /** +@@ -39077,7 +39077,7 @@ bool dotdot_is_supported_ballast_configuration_intrinsic_ballast_factor ( + * + * @returns IntrinsicBallastFactor attribute + */ +-int8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( ++uint8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39097,7 +39097,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_intrinsic_ballast_factor ++ uint8_t new_intrinsic_ballast_factor + ); + + /** +@@ -39183,7 +39183,7 @@ bool dotdot_is_supported_ballast_configuration_ballast_factor_adjustment ( + * + * @returns BallastFactorAdjustment attribute + */ +-int8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( ++uint8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39203,7 +39203,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_ballast_factor_adjustment ++ uint8_t new_ballast_factor_adjustment + ); + + /** +@@ -39289,7 +39289,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_quantity ( + * + * @returns LampQuantity attribute + */ +-int8_t dotdot_get_ballast_configuration_lamp_quantity( ++uint8_t dotdot_get_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39309,7 +39309,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_lamp_quantity ++ uint8_t new_lamp_quantity + ); + + /** +@@ -39613,7 +39613,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_rated_hours ( + * + * @returns LampRatedHours attribute + */ +-int32_t dotdot_get_ballast_configuration_lamp_rated_hours( ++uint32_t dotdot_get_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39633,7 +39633,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_rated_hours ++ uint32_t new_lamp_rated_hours + ); + + /** +@@ -39719,7 +39719,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours ( + * + * @returns LampBurnHours attribute + */ +-int32_t dotdot_get_ballast_configuration_lamp_burn_hours( ++uint32_t dotdot_get_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39739,7 +39739,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_burn_hours ++ uint32_t new_lamp_burn_hours + ); + + /** +@@ -39931,7 +39931,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours_trip_point ( + * + * @returns LampBurnHoursTripPoint attribute + */ +-int32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( ++uint32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -39951,7 +39951,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_burn_hours_trip_point ++ uint32_t new_lamp_burn_hours_trip_point + ); + + /** +@@ -40065,7 +40065,7 @@ bool dotdot_is_supported_illuminance_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_illuminance_measurement_measured_value( ++uint16_t dotdot_get_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40085,7 +40085,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -40171,7 +40171,7 @@ bool dotdot_is_supported_illuminance_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_illuminance_measurement_min_measured_value( ++uint16_t dotdot_get_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40191,7 +40191,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -40277,7 +40277,7 @@ bool dotdot_is_supported_illuminance_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_illuminance_measurement_max_measured_value( ++uint16_t dotdot_get_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40297,7 +40297,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -40383,7 +40383,7 @@ bool dotdot_is_supported_illuminance_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_illuminance_measurement_tolerance( ++uint16_t dotdot_get_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40403,7 +40403,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -40835,7 +40835,7 @@ bool dotdot_is_supported_illuminance_level_sensing_illuminance_target_level ( + * + * @returns IlluminanceTargetLevel attribute + */ +-int16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( ++uint16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -40855,7 +40855,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_illuminance_target_level ++ uint16_t new_illuminance_target_level + ); + + /** +@@ -41287,7 +41287,7 @@ bool dotdot_is_supported_temperature_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_temperature_measurement_tolerance( ++uint16_t dotdot_get_temperature_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -41307,7 +41307,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -41739,7 +41739,7 @@ bool dotdot_is_supported_pressure_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_pressure_measurement_tolerance( ++uint16_t dotdot_get_pressure_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -41759,7 +41759,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -42163,7 +42163,7 @@ bool dotdot_is_supported_pressure_measurement_scaled_tolerance ( + * + * @returns ScaledTolerance attribute + */ +-int16_t dotdot_get_pressure_measurement_scaled_tolerance( ++uint16_t dotdot_get_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42183,7 +42183,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_scaled_tolerance ++ uint16_t new_scaled_tolerance + ); + + /** +@@ -42403,7 +42403,7 @@ bool dotdot_is_supported_flow_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_flow_measurement_measured_value( ++uint16_t dotdot_get_flow_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42423,7 +42423,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -42509,7 +42509,7 @@ bool dotdot_is_supported_flow_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_flow_measurement_min_measured_value( ++uint16_t dotdot_get_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42529,7 +42529,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -42615,7 +42615,7 @@ bool dotdot_is_supported_flow_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_flow_measurement_max_measured_value( ++uint16_t dotdot_get_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42635,7 +42635,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -42721,7 +42721,7 @@ bool dotdot_is_supported_flow_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_flow_measurement_tolerance( ++uint16_t dotdot_get_flow_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42741,7 +42741,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -42855,7 +42855,7 @@ bool dotdot_is_supported_relativity_humidity_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_relativity_humidity_measured_value( ++uint16_t dotdot_get_relativity_humidity_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42875,7 +42875,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -42961,7 +42961,7 @@ bool dotdot_is_supported_relativity_humidity_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_relativity_humidity_min_measured_value( ++uint16_t dotdot_get_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -42981,7 +42981,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -43067,7 +43067,7 @@ bool dotdot_is_supported_relativity_humidity_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_relativity_humidity_max_measured_value( ++uint16_t dotdot_get_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43087,7 +43087,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -43173,7 +43173,7 @@ bool dotdot_is_supported_relativity_humidity_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_relativity_humidity_tolerance( ++uint16_t dotdot_get_relativity_humidity_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43193,7 +43193,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -43625,7 +43625,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_occupied_to_unoccupied_delay ( + * + * @returns PIROccupiedToUnoccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43645,7 +43645,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_pir_occupied_to_unoccupied_delay ++ uint16_t new_pir_occupied_to_unoccupied_delay + ); + + /** +@@ -43731,7 +43731,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_delay ( + * + * @returns PIRUnoccupiedToOccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43751,7 +43751,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_pir_unoccupied_to_occupied_delay ++ uint16_t new_pir_unoccupied_to_occupied_delay + ); + + /** +@@ -43837,7 +43837,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_threshold + * + * @returns PIRUnoccupiedToOccupiedThreshold attribute + */ +-int8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43857,7 +43857,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pir_unoccupied_to_occupied_threshold ++ uint8_t new_pir_unoccupied_to_occupied_threshold + ); + + /** +@@ -43943,7 +43943,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_occupied_to_unoccupied_del + * + * @returns UltrasonicOccupiedToUnoccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -43963,7 +43963,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ultrasonic_occupied_to_unoccupied_delay ++ uint16_t new_ultrasonic_occupied_to_unoccupied_delay + ); + + /** +@@ -44049,7 +44049,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_del + * + * @returns UltrasonicUnoccupiedToOccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44069,7 +44069,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ultrasonic_unoccupied_to_occupied_delay ++ uint16_t new_ultrasonic_unoccupied_to_occupied_delay + ); + + /** +@@ -44155,7 +44155,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thr + * + * @returns UltrasonicUnoccupiedToOccupiedThreshold attribute + */ +-int8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44175,7 +44175,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_ultrasonic_unoccupied_to_occupied_threshold ++ uint8_t new_ultrasonic_unoccupied_to_occupied_threshold + ); + + /** +@@ -44261,7 +44261,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_occupied_to_unoccupi + * + * @returns PhysicalContactOccupiedToUnoccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44281,7 +44281,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_contact_occupied_to_unoccupied_delay ++ uint16_t new_physical_contact_occupied_to_unoccupied_delay + ); + + /** +@@ -44367,7 +44367,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + * + * @returns PhysicalContactUnoccupiedToOccupiedDelay attribute + */ +-int16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44387,7 +44387,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_contact_unoccupied_to_occupied_delay ++ uint16_t new_physical_contact_unoccupied_to_occupied_delay + ); + + /** +@@ -44473,7 +44473,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + * + * @returns PhysicalContactUnoccupiedToOccupiedThreshold attribute + */ +-int8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44493,7 +44493,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_contact_unoccupied_to_occupied_threshold ++ uint8_t new_physical_contact_unoccupied_to_occupied_threshold + ); + + /** +@@ -44607,7 +44607,7 @@ bool dotdot_is_supported_soil_moisture_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_soil_moisture_measured_value( ++uint16_t dotdot_get_soil_moisture_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44627,7 +44627,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -44713,7 +44713,7 @@ bool dotdot_is_supported_soil_moisture_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_soil_moisture_min_measured_value( ++uint16_t dotdot_get_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44733,7 +44733,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -44819,7 +44819,7 @@ bool dotdot_is_supported_soil_moisture_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_soil_moisture_max_measured_value( ++uint16_t dotdot_get_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44839,7 +44839,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -44925,7 +44925,7 @@ bool dotdot_is_supported_soil_moisture_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_soil_moisture_tolerance( ++uint16_t dotdot_get_soil_moisture_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -44945,7 +44945,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -45059,7 +45059,7 @@ bool dotdot_is_supported_ph_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_ph_measurement_measured_value( ++uint16_t dotdot_get_ph_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45079,7 +45079,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -45165,7 +45165,7 @@ bool dotdot_is_supported_ph_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_ph_measurement_min_measured_value( ++uint16_t dotdot_get_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45185,7 +45185,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -45271,7 +45271,7 @@ bool dotdot_is_supported_ph_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_ph_measurement_max_measured_value( ++uint16_t dotdot_get_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45291,7 +45291,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -45377,7 +45377,7 @@ bool dotdot_is_supported_ph_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_ph_measurement_tolerance( ++uint16_t dotdot_get_ph_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45397,7 +45397,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -45511,7 +45511,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_electrical_conductivity_measurement_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45531,7 +45531,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -45617,7 +45617,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_min_measured_value + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45637,7 +45637,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -45723,7 +45723,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_max_measured_value + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45743,7 +45743,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -45829,7 +45829,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_electrical_conductivity_measurement_tolerance( ++uint16_t dotdot_get_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45849,7 +45849,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -45963,7 +45963,7 @@ bool dotdot_is_supported_wind_speed_measurement_measured_value ( + * + * @returns MeasuredValue attribute + */ +-int16_t dotdot_get_wind_speed_measurement_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -45983,7 +45983,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ); + + /** +@@ -46069,7 +46069,7 @@ bool dotdot_is_supported_wind_speed_measurement_min_measured_value ( + * + * @returns MinMeasuredValue attribute + */ +-int16_t dotdot_get_wind_speed_measurement_min_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46089,7 +46089,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ); + + /** +@@ -46175,7 +46175,7 @@ bool dotdot_is_supported_wind_speed_measurement_max_measured_value ( + * + * @returns MaxMeasuredValue attribute + */ +-int16_t dotdot_get_wind_speed_measurement_max_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46195,7 +46195,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ); + + /** +@@ -46281,7 +46281,7 @@ bool dotdot_is_supported_wind_speed_measurement_tolerance ( + * + * @returns Tolerance attribute + */ +-int16_t dotdot_get_wind_speed_measurement_tolerance( ++uint16_t dotdot_get_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -46301,7 +46301,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ); + + /** +@@ -48195,7 +48195,7 @@ bool dotdot_is_supported_ias_zone_zoneid ( + * + * @returns ZoneID attribute + */ +-int8_t dotdot_get_ias_zone_zoneid( ++uint8_t dotdot_get_ias_zone_zoneid( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48215,7 +48215,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_zoneid ++ uint8_t new_zoneid + ); + + /** +@@ -48301,7 +48301,7 @@ bool dotdot_is_supported_ias_zone_number_of_zone_sensitivity_levels_supported ( + * + * @returns NumberOfZoneSensitivityLevelsSupported attribute + */ +-int8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( ++uint8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48321,7 +48321,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_zone_sensitivity_levels_supported ++ uint8_t new_number_of_zone_sensitivity_levels_supported + ); + + /** +@@ -48407,7 +48407,7 @@ bool dotdot_is_supported_ias_zone_current_zone_sensitivity_level ( + * + * @returns CurrentZoneSensitivityLevel attribute + */ +-int8_t dotdot_get_ias_zone_current_zone_sensitivity_level( ++uint8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48427,7 +48427,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_zone_sensitivity_level ++ uint8_t new_current_zone_sensitivity_level + ); + + /** +@@ -48541,7 +48541,7 @@ bool dotdot_is_supported_iaswd_max_duration ( + * + * @returns MaxDuration attribute + */ +-int16_t dotdot_get_iaswd_max_duration( ++uint16_t dotdot_get_iaswd_max_duration( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48561,7 +48561,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_duration ++ uint16_t new_max_duration + ); + + /** +@@ -48675,7 +48675,7 @@ bool dotdot_is_supported_metering_current_summation_delivered ( + * + * @returns CurrentSummationDelivered attribute + */ +-int64_t dotdot_get_metering_current_summation_delivered( ++uint64_t dotdot_get_metering_current_summation_delivered( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48695,7 +48695,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_summation_delivered ++ uint64_t new_current_summation_delivered + ); + + /** +@@ -48781,7 +48781,7 @@ bool dotdot_is_supported_metering_current_summation_received ( + * + * @returns CurrentSummationReceived attribute + */ +-int64_t dotdot_get_metering_current_summation_received( ++uint64_t dotdot_get_metering_current_summation_received( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48801,7 +48801,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_summation_received ++ uint64_t new_current_summation_received + ); + + /** +@@ -48887,7 +48887,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered ( + * + * @returns CurrentMaxDemandDelivered attribute + */ +-int64_t dotdot_get_metering_current_max_demand_delivered( ++uint64_t dotdot_get_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -48907,7 +48907,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_max_demand_delivered ++ uint64_t new_current_max_demand_delivered + ); + + /** +@@ -49205,7 +49205,7 @@ bool dotdot_is_supported_metering_reading_snap_shot_time ( + * + * @returns ReadingSnapShotTime attribute + */ +-uint8_t dotdot_get_metering_reading_snap_shot_time( ++uint32_t dotdot_get_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49225,7 +49225,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_reading_snap_shot_time ++ uint32_t new_reading_snap_shot_time + ); + + /** +@@ -49311,7 +49311,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered_time ( + * + * @returns CurrentMaxDemandDeliveredTime attribute + */ +-uint8_t dotdot_get_metering_current_max_demand_delivered_time( ++uint32_t dotdot_get_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49331,7 +49331,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_max_demand_delivered_time ++ uint32_t new_current_max_demand_delivered_time + ); + + /** +@@ -49417,7 +49417,7 @@ bool dotdot_is_supported_metering_current_max_demand_received_time ( + * + * @returns CurrentMaxDemandReceivedTime attribute + */ +-uint8_t dotdot_get_metering_current_max_demand_received_time( ++uint32_t dotdot_get_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49437,7 +49437,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_max_demand_received_time ++ uint32_t new_current_max_demand_received_time + ); + + /** +@@ -49523,7 +49523,7 @@ bool dotdot_is_supported_metering_default_update_period ( + * + * @returns DefaultUpdatePeriod attribute + */ +-int8_t dotdot_get_metering_default_update_period( ++uint8_t dotdot_get_metering_default_update_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49543,7 +49543,7 @@ sl_status_t dotdot_set_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_default_update_period ++ uint8_t new_default_update_period + ); + + /** +@@ -49735,7 +49735,7 @@ bool dotdot_is_supported_metering_current_inlet_energy_carrier_summation ( + * + * @returns CurrentInletEnergyCarrierSummation attribute + */ +-int64_t dotdot_get_metering_current_inlet_energy_carrier_summation( ++uint64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49755,7 +49755,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_inlet_energy_carrier_summation ++ uint64_t new_current_inlet_energy_carrier_summation + ); + + /** +@@ -49841,7 +49841,7 @@ bool dotdot_is_supported_metering_current_outlet_energy_carrier_summation ( + * + * @returns CurrentOutletEnergyCarrierSummation attribute + */ +-int64_t dotdot_get_metering_current_outlet_energy_carrier_summation( ++uint64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -49861,7 +49861,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_outlet_energy_carrier_summation ++ uint64_t new_current_outlet_energy_carrier_summation + ); + + /** +@@ -50265,7 +50265,7 @@ bool dotdot_is_supported_metering_multiplier ( + * + * @returns Multiplier attribute + */ +-int32_t dotdot_get_metering_multiplier( ++uint32_t dotdot_get_metering_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -50285,7 +50285,7 @@ sl_status_t dotdot_set_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_multiplier ++ uint32_t new_multiplier + ); + + /** +@@ -50371,7 +50371,7 @@ bool dotdot_is_supported_metering_divisor ( + * + * @returns Divisor attribute + */ +-int32_t dotdot_get_metering_divisor( ++uint32_t dotdot_get_metering_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -50391,7 +50391,7 @@ sl_status_t dotdot_set_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_divisor ++ uint32_t new_divisor + ); + + /** +@@ -52519,7 +52519,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_multiplier ( + * + * @returns DCVoltageMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52539,7 +52539,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_voltage_multiplier ++ uint16_t new_dc_voltage_multiplier + ); + + /** +@@ -52625,7 +52625,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_divisor ( + * + * @returns DCVoltageDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_voltage_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52645,7 +52645,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_voltage_divisor ++ uint16_t new_dc_voltage_divisor + ); + + /** +@@ -52731,7 +52731,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_multiplier ( + * + * @returns DCCurrentMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_current_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52751,7 +52751,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_current_multiplier ++ uint16_t new_dc_current_multiplier + ); + + /** +@@ -52837,7 +52837,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_divisor ( + * + * @returns DCCurrentDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_current_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52857,7 +52857,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_current_divisor ++ uint16_t new_dc_current_divisor + ); + + /** +@@ -52943,7 +52943,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_multiplier ( + * + * @returns DCPowerMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_power_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -52963,7 +52963,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_power_multiplier ++ uint16_t new_dc_power_multiplier + ); + + /** +@@ -53049,7 +53049,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_divisor ( + * + * @returns DCPowerDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_dc_power_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53069,7 +53069,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_power_divisor ++ uint16_t new_dc_power_divisor + ); + + /** +@@ -53155,7 +53155,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency ( + * + * @returns ACFrequency attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_frequency( ++uint16_t dotdot_get_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53175,7 +53175,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency ++ uint16_t new_ac_frequency + ); + + /** +@@ -53261,7 +53261,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_min ( + * + * @returns ACFrequencyMin attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_frequency_min( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53281,7 +53281,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_min ++ uint16_t new_ac_frequency_min + ); + + /** +@@ -53367,7 +53367,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_max ( + * + * @returns ACFrequencyMax attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_frequency_max( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53387,7 +53387,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_max ++ uint16_t new_ac_frequency_max + ); + + /** +@@ -53473,7 +53473,7 @@ bool dotdot_is_supported_electrical_measurement_neutral_current ( + * + * @returns NeutralCurrent attribute + */ +-int16_t dotdot_get_electrical_measurement_neutral_current( ++uint16_t dotdot_get_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53493,7 +53493,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neutral_current ++ uint16_t new_neutral_current + ); + + /** +@@ -53791,7 +53791,7 @@ bool dotdot_is_supported_electrical_measurement_total_apparent_power ( + * + * @returns TotalApparentPower attribute + */ +-int32_t dotdot_get_electrical_measurement_total_apparent_power( ++uint32_t dotdot_get_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -53811,7 +53811,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_total_apparent_power ++ uint32_t new_total_apparent_power + ); + + /** +@@ -55169,7 +55169,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_multiplier ( + * + * @returns ACFrequencyMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55189,7 +55189,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_multiplier ++ uint16_t new_ac_frequency_multiplier + ); + + /** +@@ -55275,7 +55275,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_divisor ( + * + * @returns ACFrequencyDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_frequency_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55295,7 +55295,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_divisor ++ uint16_t new_ac_frequency_divisor + ); + + /** +@@ -55381,7 +55381,7 @@ bool dotdot_is_supported_electrical_measurement_power_multiplier ( + * + * @returns PowerMultiplier attribute + */ +-int32_t dotdot_get_electrical_measurement_power_multiplier( ++uint32_t dotdot_get_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55401,7 +55401,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power_multiplier ++ uint32_t new_power_multiplier + ); + + /** +@@ -55487,7 +55487,7 @@ bool dotdot_is_supported_electrical_measurement_power_divisor ( + * + * @returns PowerDivisor attribute + */ +-int32_t dotdot_get_electrical_measurement_power_divisor( ++uint32_t dotdot_get_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55507,7 +55507,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power_divisor ++ uint32_t new_power_divisor + ); + + /** +@@ -55805,7 +55805,7 @@ bool dotdot_is_supported_electrical_measurement_line_current ( + * + * @returns LineCurrent attribute + */ +-int16_t dotdot_get_electrical_measurement_line_current( ++uint16_t dotdot_get_electrical_measurement_line_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -55825,7 +55825,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current ++ uint16_t new_line_current + ); + + /** +@@ -56123,7 +56123,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage ( + * + * @returns RMSVoltage attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage( ++uint16_t dotdot_get_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56143,7 +56143,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage ++ uint16_t new_rms_voltage + ); + + /** +@@ -56229,7 +56229,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min ( + * + * @returns RMSVoltageMin attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_min( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56249,7 +56249,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min ++ uint16_t new_rms_voltage_min + ); + + /** +@@ -56335,7 +56335,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max ( + * + * @returns RMSVoltageMax attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_max( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56355,7 +56355,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max ++ uint16_t new_rms_voltage_max + ); + + /** +@@ -56441,7 +56441,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current ( + * + * @returns RMSCurrent attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current( ++uint16_t dotdot_get_electrical_measurement_rms_current( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56461,7 +56461,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current ++ uint16_t new_rms_current + ); + + /** +@@ -56547,7 +56547,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min ( + * + * @returns RMSCurrentMin attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_min( ++uint16_t dotdot_get_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56567,7 +56567,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min ++ uint16_t new_rms_current_min + ); + + /** +@@ -56653,7 +56653,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max ( + * + * @returns RMSCurrentMax attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_max( ++uint16_t dotdot_get_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -56673,7 +56673,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max ++ uint16_t new_rms_current_max + ); + + /** +@@ -57183,7 +57183,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power ( + * + * @returns ApparentPower attribute + */ +-int16_t dotdot_get_electrical_measurement_apparent_power( ++uint16_t dotdot_get_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57203,7 +57203,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power ++ uint16_t new_apparent_power + ); + + /** +@@ -57395,7 +57395,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriod attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57415,7 +57415,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period ++ uint16_t new_average_rms_voltage_measurement_period + ); + + /** +@@ -57501,7 +57501,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounter attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57521,7 +57521,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter ++ uint16_t new_average_rms_over_voltage_counter + ); + + /** +@@ -57607,7 +57607,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounter attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57627,7 +57627,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter ++ uint16_t new_average_rms_under_voltage_counter + ); + + /** +@@ -57713,7 +57713,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period + * + * @returns RMSExtremeOverVoltagePeriod attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57733,7 +57733,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period ++ uint16_t new_rms_extreme_over_voltage_period + ); + + /** +@@ -57819,7 +57819,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriod attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57839,7 +57839,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period ++ uint16_t new_rms_extreme_under_voltage_period + ); + + /** +@@ -57925,7 +57925,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period ( + * + * @returns RMSVoltageSagPeriod attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -57945,7 +57945,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period ++ uint16_t new_rms_voltage_sag_period + ); + + /** +@@ -58031,7 +58031,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period ( + * + * @returns RMSVoltageSwellPeriod attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58051,7 +58051,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period ++ uint16_t new_rms_voltage_swell_period + ); + + /** +@@ -58137,7 +58137,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_multiplier ( + * + * @returns ACVoltageMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58157,7 +58157,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_voltage_multiplier ++ uint16_t new_ac_voltage_multiplier + ); + + /** +@@ -58243,7 +58243,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_divisor ( + * + * @returns ACVoltageDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_voltage_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58263,7 +58263,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_voltage_divisor ++ uint16_t new_ac_voltage_divisor + ); + + /** +@@ -58349,7 +58349,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_multiplier ( + * + * @returns ACCurrentMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_current_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58369,7 +58369,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_current_multiplier ++ uint16_t new_ac_current_multiplier + ); + + /** +@@ -58455,7 +58455,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_divisor ( + * + * @returns ACCurrentDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_current_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58475,7 +58475,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_current_divisor ++ uint16_t new_ac_current_divisor + ); + + /** +@@ -58561,7 +58561,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_multiplier ( + * + * @returns ACPowerMultiplier attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_power_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58581,7 +58581,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_power_multiplier ++ uint16_t new_ac_power_multiplier + ); + + /** +@@ -58667,7 +58667,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_divisor ( + * + * @returns ACPowerDivisor attribute + */ +-int16_t dotdot_get_electrical_measurement_ac_power_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -58687,7 +58687,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_power_divisor ++ uint16_t new_ac_power_divisor + ); + + /** +@@ -60257,7 +60257,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phb ( + * + * @returns LineCurrentPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_line_current_phb( ++uint16_t dotdot_get_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60277,7 +60277,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current_phb ++ uint16_t new_line_current_phb + ); + + /** +@@ -60575,7 +60575,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phb ( + * + * @returns RMSVoltagePhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60595,7 +60595,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_phb ++ uint16_t new_rms_voltage_phb + ); + + /** +@@ -60681,7 +60681,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phb ( + * + * @returns RMSVoltageMinPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60701,7 +60701,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min_phb ++ uint16_t new_rms_voltage_min_phb + ); + + /** +@@ -60787,7 +60787,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phb ( + * + * @returns RMSVoltageMaxPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60807,7 +60807,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max_phb ++ uint16_t new_rms_voltage_max_phb + ); + + /** +@@ -60893,7 +60893,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phb ( + * + * @returns RMSCurrentPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -60913,7 +60913,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_phb ++ uint16_t new_rms_current_phb + ); + + /** +@@ -60999,7 +60999,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phb ( + * + * @returns RMSCurrentMinPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_min_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61019,7 +61019,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min_phb ++ uint16_t new_rms_current_min_phb + ); + + /** +@@ -61105,7 +61105,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phb ( + * + * @returns RMSCurrentMaxPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_max_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61125,7 +61125,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max_phb ++ uint16_t new_rms_current_max_phb + ); + + /** +@@ -61635,7 +61635,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phb ( + * + * @returns ApparentPowerPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_apparent_power_phb( ++uint16_t dotdot_get_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61655,7 +61655,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power_phb ++ uint16_t new_apparent_power_phb + ); + + /** +@@ -61847,7 +61847,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriodPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61867,7 +61867,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period_phb ++ uint16_t new_average_rms_voltage_measurement_period_phb + ); + + /** +@@ -61953,7 +61953,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounterPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -61973,7 +61973,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter_phb ++ uint16_t new_average_rms_over_voltage_counter_phb + ); + + /** +@@ -62059,7 +62059,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounterPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62079,7 +62079,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter_phb ++ uint16_t new_average_rms_under_voltage_counter_phb + ); + + /** +@@ -62165,7 +62165,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + * + * @returns RMSExtremeOverVoltagePeriodPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62185,7 +62185,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period_phb ++ uint16_t new_rms_extreme_over_voltage_period_phb + ); + + /** +@@ -62271,7 +62271,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriodPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62291,7 +62291,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period_phb ++ uint16_t new_rms_extreme_under_voltage_period_phb + ); + + /** +@@ -62377,7 +62377,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phb ( + * + * @returns RMSVoltageSagPeriodPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62397,7 +62397,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period_phb ++ uint16_t new_rms_voltage_sag_period_phb + ); + + /** +@@ -62483,7 +62483,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phb ( + * + * @returns RMSVoltageSwellPeriodPhB attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62503,7 +62503,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period_phb ++ uint16_t new_rms_voltage_swell_period_phb + ); + + /** +@@ -62589,7 +62589,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phc ( + * + * @returns LineCurrentPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_line_current_phc( ++uint16_t dotdot_get_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62609,7 +62609,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current_phc ++ uint16_t new_line_current_phc + ); + + /** +@@ -62907,7 +62907,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phc ( + * + * @returns RMSVoltagePhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -62927,7 +62927,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_phc ++ uint16_t new_rms_voltage_phc + ); + + /** +@@ -63013,7 +63013,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phc ( + * + * @returns RMSVoltageMinPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63033,7 +63033,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min_phc ++ uint16_t new_rms_voltage_min_phc + ); + + /** +@@ -63119,7 +63119,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phc ( + * + * @returns RMSVoltageMaxPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63139,7 +63139,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max_phc ++ uint16_t new_rms_voltage_max_phc + ); + + /** +@@ -63225,7 +63225,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phc ( + * + * @returns RMSCurrentPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63245,7 +63245,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_phc ++ uint16_t new_rms_current_phc + ); + + /** +@@ -63331,7 +63331,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phc ( + * + * @returns RMSCurrentMinPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_min_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63351,7 +63351,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min_phc ++ uint16_t new_rms_current_min_phc + ); + + /** +@@ -63437,7 +63437,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phc ( + * + * @returns RMSCurrentMaxPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_current_max_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63457,7 +63457,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max_phc ++ uint16_t new_rms_current_max_phc + ); + + /** +@@ -63967,7 +63967,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phc ( + * + * @returns ApparentPowerPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_apparent_power_phc( ++uint16_t dotdot_get_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -63987,7 +63987,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power_phc ++ uint16_t new_apparent_power_phc + ); + + /** +@@ -64179,7 +64179,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + * + * @returns AverageRMSVoltageMeasurementPeriodPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64199,7 +64199,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period_phc ++ uint16_t new_average_rms_voltage_measurement_period_phc + ); + + /** +@@ -64285,7 +64285,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + * + * @returns AverageRMSOverVoltageCounterPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64305,7 +64305,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter_phc ++ uint16_t new_average_rms_over_voltage_counter_phc + ); + + /** +@@ -64391,7 +64391,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + * + * @returns AverageRMSUnderVoltageCounterPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64411,7 +64411,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter_phc ++ uint16_t new_average_rms_under_voltage_counter_phc + ); + + /** +@@ -64497,7 +64497,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + * + * @returns RMSExtremeOverVoltagePeriodPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64517,7 +64517,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period_phc ++ uint16_t new_rms_extreme_over_voltage_period_phc + ); + + /** +@@ -64603,7 +64603,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + * + * @returns RMSExtremeUnderVoltagePeriodPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64623,7 +64623,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period_phc ++ uint16_t new_rms_extreme_under_voltage_period_phc + ); + + /** +@@ -64709,7 +64709,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phc ( + * + * @returns RMSVoltageSagPeriodPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64729,7 +64729,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period_phc ++ uint16_t new_rms_voltage_sag_period_phc + ); + + /** +@@ -64815,7 +64815,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phc ( + * + * @returns RMSVoltageSwellPeriodPhC attribute + */ +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64835,7 +64835,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period_phc ++ uint16_t new_rms_voltage_swell_period_phc + ); + + /** +@@ -64949,7 +64949,7 @@ bool dotdot_is_supported_diagnostics_number_of_resets ( + * + * @returns NumberOfResets attribute + */ +-int16_t dotdot_get_diagnostics_number_of_resets( ++uint16_t dotdot_get_diagnostics_number_of_resets( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -64969,7 +64969,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_resets ++ uint16_t new_number_of_resets + ); + + /** +@@ -65055,7 +65055,7 @@ bool dotdot_is_supported_diagnostics_persistent_memory_writes ( + * + * @returns PersistentMemoryWrites attribute + */ +-int16_t dotdot_get_diagnostics_persistent_memory_writes( ++uint16_t dotdot_get_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65075,7 +65075,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_persistent_memory_writes ++ uint16_t new_persistent_memory_writes + ); + + /** +@@ -65161,7 +65161,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_bcast ( + * + * @returns MacRxBcast attribute + */ +-int32_t dotdot_get_diagnostics_mac_rx_bcast( ++uint32_t dotdot_get_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65181,7 +65181,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_rx_bcast ++ uint32_t new_mac_rx_bcast + ); + + /** +@@ -65267,7 +65267,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_bcast ( + * + * @returns MacTxBcast attribute + */ +-int32_t dotdot_get_diagnostics_mac_tx_bcast( ++uint32_t dotdot_get_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65287,7 +65287,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_tx_bcast ++ uint32_t new_mac_tx_bcast + ); + + /** +@@ -65373,7 +65373,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_ucast ( + * + * @returns MacRxUcast attribute + */ +-int32_t dotdot_get_diagnostics_mac_rx_ucast( ++uint32_t dotdot_get_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65393,7 +65393,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_rx_ucast ++ uint32_t new_mac_rx_ucast + ); + + /** +@@ -65479,7 +65479,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast ( + * + * @returns MacTxUcast attribute + */ +-int32_t dotdot_get_diagnostics_mac_tx_ucast( ++uint32_t dotdot_get_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65499,7 +65499,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_tx_ucast ++ uint32_t new_mac_tx_ucast + ); + + /** +@@ -65585,7 +65585,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_retry ( + * + * @returns MacTxUcastRetry attribute + */ +-int16_t dotdot_get_diagnostics_mac_tx_ucast_retry( ++uint16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65605,7 +65605,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mac_tx_ucast_retry ++ uint16_t new_mac_tx_ucast_retry + ); + + /** +@@ -65691,7 +65691,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_fail ( + * + * @returns MacTxUcastFail attribute + */ +-int16_t dotdot_get_diagnostics_mac_tx_ucast_fail( ++uint16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65711,7 +65711,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mac_tx_ucast_fail ++ uint16_t new_mac_tx_ucast_fail + ); + + /** +@@ -65797,7 +65797,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_bcast ( + * + * @returns APSRxBcast attribute + */ +-int16_t dotdot_get_diagnostics_aps_rx_bcast( ++uint16_t dotdot_get_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65817,7 +65817,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_rx_bcast ++ uint16_t new_aps_rx_bcast + ); + + /** +@@ -65903,7 +65903,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_bcast ( + * + * @returns APSTxBcast attribute + */ +-int16_t dotdot_get_diagnostics_aps_tx_bcast( ++uint16_t dotdot_get_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -65923,7 +65923,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_bcast ++ uint16_t new_aps_tx_bcast + ); + + /** +@@ -66009,7 +66009,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_ucast ( + * + * @returns APSRxUcast attribute + */ +-int16_t dotdot_get_diagnostics_aps_rx_ucast( ++uint16_t dotdot_get_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66029,7 +66029,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_rx_ucast ++ uint16_t new_aps_rx_ucast + ); + + /** +@@ -66115,7 +66115,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_success ( + * + * @returns APSTxUcastSuccess attribute + */ +-int16_t dotdot_get_diagnostics_aps_tx_ucast_success( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66135,7 +66135,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_success ++ uint16_t new_aps_tx_ucast_success + ); + + /** +@@ -66221,7 +66221,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_retry ( + * + * @returns APSTxUcastRetry attribute + */ +-int16_t dotdot_get_diagnostics_aps_tx_ucast_retry( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66241,7 +66241,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_retry ++ uint16_t new_aps_tx_ucast_retry + ); + + /** +@@ -66327,7 +66327,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_fail ( + * + * @returns APSTxUcastFail attribute + */ +-int16_t dotdot_get_diagnostics_aps_tx_ucast_fail( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66347,7 +66347,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_fail ++ uint16_t new_aps_tx_ucast_fail + ); + + /** +@@ -66433,7 +66433,7 @@ bool dotdot_is_supported_diagnostics_route_disc_initiated ( + * + * @returns RouteDiscInitiated attribute + */ +-int16_t dotdot_get_diagnostics_route_disc_initiated( ++uint16_t dotdot_get_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66453,7 +66453,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_route_disc_initiated ++ uint16_t new_route_disc_initiated + ); + + /** +@@ -66539,7 +66539,7 @@ bool dotdot_is_supported_diagnostics_neighbor_added ( + * + * @returns NeighborAdded attribute + */ +-int16_t dotdot_get_diagnostics_neighbor_added( ++uint16_t dotdot_get_diagnostics_neighbor_added( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66559,7 +66559,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_added ++ uint16_t new_neighbor_added + ); + + /** +@@ -66645,7 +66645,7 @@ bool dotdot_is_supported_diagnostics_neighbor_removed ( + * + * @returns NeighborRemoved attribute + */ +-int16_t dotdot_get_diagnostics_neighbor_removed( ++uint16_t dotdot_get_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66665,7 +66665,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_removed ++ uint16_t new_neighbor_removed + ); + + /** +@@ -66751,7 +66751,7 @@ bool dotdot_is_supported_diagnostics_neighbor_stale ( + * + * @returns NeighborStale attribute + */ +-int16_t dotdot_get_diagnostics_neighbor_stale( ++uint16_t dotdot_get_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66771,7 +66771,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_stale ++ uint16_t new_neighbor_stale + ); + + /** +@@ -66857,7 +66857,7 @@ bool dotdot_is_supported_diagnostics_join_indication ( + * + * @returns JoinIndication attribute + */ +-int16_t dotdot_get_diagnostics_join_indication( ++uint16_t dotdot_get_diagnostics_join_indication( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66877,7 +66877,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_join_indication ++ uint16_t new_join_indication + ); + + /** +@@ -66963,7 +66963,7 @@ bool dotdot_is_supported_diagnostics_child_moved ( + * + * @returns ChildMoved attribute + */ +-int16_t dotdot_get_diagnostics_child_moved( ++uint16_t dotdot_get_diagnostics_child_moved( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -66983,7 +66983,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_child_moved ++ uint16_t new_child_moved + ); + + /** +@@ -67069,7 +67069,7 @@ bool dotdot_is_supported_diagnostics_nwkfc_failure ( + * + * @returns NWKFCFailure attribute + */ +-int16_t dotdot_get_diagnostics_nwkfc_failure( ++uint16_t dotdot_get_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67089,7 +67089,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_nwkfc_failure ++ uint16_t new_nwkfc_failure + ); + + /** +@@ -67175,7 +67175,7 @@ bool dotdot_is_supported_diagnostics_apsfc_failure ( + * + * @returns APSFCFailure attribute + */ +-int16_t dotdot_get_diagnostics_apsfc_failure( ++uint16_t dotdot_get_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67195,7 +67195,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apsfc_failure ++ uint16_t new_apsfc_failure + ); + + /** +@@ -67281,7 +67281,7 @@ bool dotdot_is_supported_diagnostics_aps_unauthorized_key ( + * + * @returns APSUnauthorizedKey attribute + */ +-int16_t dotdot_get_diagnostics_aps_unauthorized_key( ++uint16_t dotdot_get_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67301,7 +67301,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_unauthorized_key ++ uint16_t new_aps_unauthorized_key + ); + + /** +@@ -67387,7 +67387,7 @@ bool dotdot_is_supported_diagnostics_nwk_decrypt_failures ( + * + * @returns NWKDecryptFailures attribute + */ +-int16_t dotdot_get_diagnostics_nwk_decrypt_failures( ++uint16_t dotdot_get_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67407,7 +67407,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_nwk_decrypt_failures ++ uint16_t new_nwk_decrypt_failures + ); + + /** +@@ -67493,7 +67493,7 @@ bool dotdot_is_supported_diagnostics_aps_decrypt_failures ( + * + * @returns APSDecryptFailures attribute + */ +-int16_t dotdot_get_diagnostics_aps_decrypt_failures( ++uint16_t dotdot_get_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67513,7 +67513,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_decrypt_failures ++ uint16_t new_aps_decrypt_failures + ); + + /** +@@ -67599,7 +67599,7 @@ bool dotdot_is_supported_diagnostics_packet_buffer_allocate_failures ( + * + * @returns PacketBufferAllocateFailures attribute + */ +-int16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( ++uint16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67619,7 +67619,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_packet_buffer_allocate_failures ++ uint16_t new_packet_buffer_allocate_failures + ); + + /** +@@ -67705,7 +67705,7 @@ bool dotdot_is_supported_diagnostics_relayed_ucast ( + * + * @returns RelayedUcast attribute + */ +-int16_t dotdot_get_diagnostics_relayed_ucast( ++uint16_t dotdot_get_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67725,7 +67725,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_relayed_ucast ++ uint16_t new_relayed_ucast + ); + + /** +@@ -67811,7 +67811,7 @@ bool dotdot_is_supported_diagnostics_phy_to_mac_queue_limit_reached ( + * + * @returns PHYToMACQueueLimitReached attribute + */ +-int16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( ++uint16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67831,7 +67831,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_phy_to_mac_queue_limit_reached ++ uint16_t new_phy_to_mac_queue_limit_reached + ); + + /** +@@ -67917,7 +67917,7 @@ bool dotdot_is_supported_diagnostics_packet_validate_drop_count ( + * + * @returns PacketValidateDropCount attribute + */ +-int16_t dotdot_get_diagnostics_packet_validate_drop_count( ++uint16_t dotdot_get_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -67937,7 +67937,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_packet_validate_drop_count ++ uint16_t new_packet_validate_drop_count + ); + + /** +@@ -68023,7 +68023,7 @@ bool dotdot_is_supported_diagnostics_average_mac_retry_per_aps_message_sent ( + * + * @returns AverageMACRetryPerAPSMessageSent attribute + */ +-int16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( ++uint16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68043,7 +68043,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_mac_retry_per_aps_message_sent ++ uint16_t new_average_mac_retry_per_aps_message_sent + ); + + /** +@@ -68129,7 +68129,7 @@ bool dotdot_is_supported_diagnostics_last_messagelqi ( + * + * @returns LastMessageLQI attribute + */ +-int8_t dotdot_get_diagnostics_last_messagelqi( ++uint8_t dotdot_get_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68149,7 +68149,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_last_messagelqi ++ uint8_t new_last_messagelqi + ); + + /** +@@ -68609,7 +68609,7 @@ bool dotdot_is_supported_state_endpoint_id_list ( + * + * @returns EndpointIdList attribute + */ +-int8_t dotdot_get_state_endpoint_id_list( ++uint8_t dotdot_get_state_endpoint_id_list( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68632,7 +68632,7 @@ sl_status_t dotdot_set_state_endpoint_id_list( + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, + size_t new_endpoint_id_list_count, +- const int8_t* new_endpoint_id_list ++ const uint8_t* new_endpoint_id_list + ); + + /** +@@ -68930,7 +68930,7 @@ bool dotdot_is_supported_state_maximum_command_delay ( + * + * @returns MaximumCommandDelay attribute + */ +-int32_t dotdot_get_state_maximum_command_delay( ++uint32_t dotdot_get_state_maximum_command_delay( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -68950,7 +68950,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_maximum_command_delay ++ uint32_t new_maximum_command_delay + ); + + /** +@@ -69531,7 +69531,7 @@ bool dotdot_is_supported_system_metrics_reporting_interval_seconds ( + * + * @returns ReportingIntervalSeconds attribute + */ +-int32_t dotdot_get_system_metrics_reporting_interval_seconds( ++uint32_t dotdot_get_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -69551,7 +69551,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_reporting_interval_seconds ++ uint32_t new_reporting_interval_seconds + ); + + /** +@@ -71578,7 +71578,7 @@ bool dotdot_is_supported_system_metrics_uptime_minutes ( + * + * @returns UptimeMinutes attribute + */ +-int64_t dotdot_get_system_metrics_uptime_minutes( ++uint64_t dotdot_get_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -71598,7 +71598,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_uptime_minutes ++ uint64_t new_uptime_minutes + ); + + /** +@@ -72320,7 +72320,7 @@ bool dotdot_is_supported_system_metrics_system_interrupts ( + * + * @returns SystemInterrupts attribute + */ +-int64_t dotdot_get_system_metrics_system_interrupts( ++uint64_t dotdot_get_system_metrics_system_interrupts( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -72340,7 +72340,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_system_interrupts ++ uint64_t new_system_interrupts + ); + + /** +@@ -72890,7 +72890,7 @@ bool dotdot_is_supported_application_monitoring_uptime_minutes ( + * + * @returns UptimeMinutes attribute + */ +-int64_t dotdot_get_application_monitoring_uptime_minutes( ++uint64_t dotdot_get_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -72910,7 +72910,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_uptime_minutes ++ uint64_t new_uptime_minutes + ); + + /** +@@ -72996,7 +72996,7 @@ bool dotdot_is_supported_application_monitoring_process_id ( + * + * @returns ProcessId attribute + */ +-int64_t dotdot_get_application_monitoring_process_id( ++uint64_t dotdot_get_application_monitoring_process_id( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73016,7 +73016,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_process_id ++ uint64_t new_process_id + ); + + /** +@@ -73532,7 +73532,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_statistics_reporting_interv + * + * @returns MQTTStatisticsReportingIntervalSeconds attribute + */ +-int32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( ++uint32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73552,7 +73552,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mqtt_statistics_reporting_interval_seconds ++ uint32_t new_mqtt_statistics_reporting_interval_seconds + ); + + /** +@@ -73638,7 +73638,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_sent ( + * + * @returns MQTTMessagesSent attribute + */ +-int64_t dotdot_get_application_monitoring_mqtt_messages_sent( ++uint64_t dotdot_get_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73658,7 +73658,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_messages_sent ++ uint64_t new_mqtt_messages_sent + ); + + /** +@@ -73744,7 +73744,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_received ( + * + * @returns MQTTMessagesReceived attribute + */ +-int64_t dotdot_get_application_monitoring_mqtt_messages_received( ++uint64_t dotdot_get_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73764,7 +73764,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_messages_received ++ uint64_t new_mqtt_messages_received + ); + + /** +@@ -73850,7 +73850,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_subscription_count ( + * + * @returns MQTTSubscriptionCount attribute + */ +-int64_t dotdot_get_application_monitoring_mqtt_subscription_count( ++uint64_t dotdot_get_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -73870,7 +73870,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_subscription_count ++ uint64_t new_mqtt_subscription_count + ); + + /** +@@ -74274,7 +74274,7 @@ bool dotdot_is_supported_application_monitoring_application_statistics_reporting + * + * @returns ApplicationStatisticsReportingIntervalSeconds attribute + */ +-int32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( ++uint32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -74294,7 +74294,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_application_statistics_reporting_interval_seconds ++ uint32_t new_application_statistics_reporting_interval_seconds + ); + + /** +@@ -75321,7 +75321,7 @@ bool dotdot_is_supported_user_credential_supported_user_unique_identifiers ( + * + * @returns SupportedUserUniqueIdentifiers attribute + */ +-int16_t dotdot_get_user_credential_supported_user_unique_identifiers( ++uint16_t dotdot_get_user_credential_supported_user_unique_identifiers( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -75341,7 +75341,7 @@ sl_status_t dotdot_set_user_credential_supported_user_unique_identifiers( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_supported_user_unique_identifiers ++ uint16_t new_supported_user_unique_identifiers + ); + + /** +@@ -78011,7 +78011,7 @@ bool dotdot_is_supported_unify_humidity_control_humidifier_setpoint_precision ( + * + * @returns HumidifierSetpointPrecision attribute + */ +-int8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -78031,7 +78031,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_humidifier_setpoint_precision ++ uint8_t new_humidifier_setpoint_precision + ); + + /** +@@ -78541,7 +78541,7 @@ bool dotdot_is_supported_unify_humidity_control_dehumidifier_setpoint_precision + * + * @returns DehumidifierSetpointPrecision attribute + */ +-int8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -78561,7 +78561,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidifier_setpoint_precision ++ uint8_t new_dehumidifier_setpoint_precision + ); + + /** +@@ -79071,7 +79071,7 @@ bool dotdot_is_supported_unify_humidity_control_auto_setpoint_precision ( + * + * @returns AutoSetpointPrecision attribute + */ +-int8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + const dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state); +@@ -79091,7 +79091,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_auto_setpoint_precision ++ uint8_t new_auto_setpoint_precision + ); + + /** +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp +index ab1a977fa1..75631aebad 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_attribute_publisher.cpp +@@ -98,28 +98,28 @@ static void basic_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION) { + uic_mqtt_dotdot_basic_zcl_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION) { + uic_mqtt_dotdot_basic_application_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION) { + uic_mqtt_dotdot_basic_stack_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION) { + uic_mqtt_dotdot_basic_hw_version_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -172,7 +172,7 @@ static void basic_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_basic_product_code_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -501,28 +501,28 @@ static void basic_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION) { + uic_mqtt_dotdot_basic_zcl_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION) { + uic_mqtt_dotdot_basic_application_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION) { + uic_mqtt_dotdot_basic_stack_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION) { + uic_mqtt_dotdot_basic_hw_version_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -575,7 +575,7 @@ static void basic_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_basic_product_code_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -773,14 +773,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY) { + uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -794,35 +794,35 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -844,21 +844,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING) { + uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -872,56 +872,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -935,14 +935,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -964,21 +964,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -992,56 +992,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1055,14 +1055,14 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1084,21 +1084,21 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1112,56 +1112,56 @@ static void power_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -1709,14 +1709,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_mains_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY) { + uic_mqtt_dotdot_power_configuration_mains_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1730,35 +1730,35 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_mains_voltage_max_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_power_configuration_mains_voltage_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1780,21 +1780,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING) { + uic_mqtt_dotdot_power_configuration_batterya_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1808,56 +1808,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1871,14 +1871,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1900,21 +1900,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery2a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery2_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery2_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1928,56 +1928,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery2_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -1991,14 +1991,14 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_remaining_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2020,21 +2020,21 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING) { + uic_mqtt_dotdot_power_configuration_battery3a_hr_rating_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY) { + uic_mqtt_dotdot_power_configuration_battery3_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE) { + uic_mqtt_dotdot_power_configuration_battery3_rated_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2048,56 +2048,56 @@ static void power_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_voltage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_min_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold1_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold2_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3) { + uic_mqtt_dotdot_power_configuration_battery3_percentage_threshold3_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2247,7 +2247,7 @@ static void device_temperature_configuration_cluster_publish_desired_value_callb + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL) { + uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2275,14 +2275,14 @@ static void device_temperature_configuration_cluster_publish_desired_value_callb + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2460,7 +2460,7 @@ static void device_temperature_configuration_cluster_publish_reported_value_call + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL) { + uic_mqtt_dotdot_device_temperature_configuration_over_temp_total_dwell_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2488,14 +2488,14 @@ static void device_temperature_configuration_cluster_publish_reported_value_call + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_low_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT) { + uic_mqtt_dotdot_device_temperature_configuration_high_temp_dwell_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -2617,7 +2617,7 @@ static void identify_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME) { + uic_mqtt_dotdot_identify_identify_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -2710,7 +2710,7 @@ static void identify_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME) { + uic_mqtt_dotdot_identify_identify_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3047,21 +3047,21 @@ static void scenes_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT) { + uic_mqtt_dotdot_scenes_scene_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE) { + uic_mqtt_dotdot_scenes_current_scene_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP) { + uic_mqtt_dotdot_scenes_current_group_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3226,21 +3226,21 @@ static void scenes_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT) { + uic_mqtt_dotdot_scenes_scene_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE) { + uic_mqtt_dotdot_scenes_current_scene_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP) { + uic_mqtt_dotdot_scenes_current_group_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3400,14 +3400,14 @@ static void on_off_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME) { + uic_mqtt_dotdot_on_off_on_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME) { + uic_mqtt_dotdot_on_off_off_wait_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3553,14 +3553,14 @@ static void on_off_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME) { + uic_mqtt_dotdot_on_off_on_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME) { + uic_mqtt_dotdot_on_off_off_wait_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -3689,49 +3689,49 @@ static void level_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_current_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME) { + uic_mqtt_dotdot_level_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL) { + uic_mqtt_dotdot_level_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL) { + uic_mqtt_dotdot_level_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY) { + uic_mqtt_dotdot_level_current_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY) { + uic_mqtt_dotdot_level_min_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY) { + uic_mqtt_dotdot_level_max_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3745,42 +3745,42 @@ static void level_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL) { + uic_mqtt_dotdot_level_on_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE) { + uic_mqtt_dotdot_level_default_move_rate_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_start_up_current_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -3977,49 +3977,49 @@ static void level_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_current_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME) { + uic_mqtt_dotdot_level_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL) { + uic_mqtt_dotdot_level_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL) { + uic_mqtt_dotdot_level_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY) { + uic_mqtt_dotdot_level_current_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY) { + uic_mqtt_dotdot_level_min_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY) { + uic_mqtt_dotdot_level_max_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4033,42 +4033,42 @@ static void level_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL) { + uic_mqtt_dotdot_level_on_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME) { + uic_mqtt_dotdot_level_on_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME) { + uic_mqtt_dotdot_level_off_transition_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE) { + uic_mqtt_dotdot_level_default_move_rate_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL) { + uic_mqtt_dotdot_level_start_up_current_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4190,7 +4190,7 @@ static void alarms_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT) { + uic_mqtt_dotdot_alarms_alarm_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4283,7 +4283,7 @@ static void alarms_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT) { + uic_mqtt_dotdot_alarms_alarm_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4405,7 +4405,7 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_TIME) { + uic_mqtt_dotdot_time_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4426,14 +4426,14 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_START) { + uic_mqtt_dotdot_time_dst_start_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_END) { + uic_mqtt_dotdot_time_dst_end_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4447,28 +4447,28 @@ static void time_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME) { + uic_mqtt_dotdot_time_standard_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME) { + uic_mqtt_dotdot_time_local_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME) { + uic_mqtt_dotdot_time_last_set_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME) { + uic_mqtt_dotdot_time_valid_until_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -4633,7 +4633,7 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_TIME) { + uic_mqtt_dotdot_time_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4654,14 +4654,14 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_START) { + uic_mqtt_dotdot_time_dst_start_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_DST_END) { + uic_mqtt_dotdot_time_dst_end_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4675,28 +4675,28 @@ static void time_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME) { + uic_mqtt_dotdot_time_standard_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME) { + uic_mqtt_dotdot_time_local_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME) { + uic_mqtt_dotdot_time_last_set_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME) { + uic_mqtt_dotdot_time_valid_until_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -4818,49 +4818,49 @@ static void poll_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL) { + uic_mqtt_dotdot_poll_control_check_in_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5001,49 +5001,49 @@ static void poll_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL) { + uic_mqtt_dotdot_poll_control_check_in_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_long_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL) { + uic_mqtt_dotdot_poll_control_short_poll_interval_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_check_in_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN) { + uic_mqtt_dotdot_poll_control_long_poll_interval_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX) { + uic_mqtt_dotdot_poll_control_fast_poll_timeout_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5165,14 +5165,14 @@ static void shade_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE) { + uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5186,7 +5186,7 @@ static void shade_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5318,14 +5318,14 @@ static void shade_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_physical_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE) { + uic_mqtt_dotdot_shade_configuration_motor_step_size_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5339,7 +5339,7 @@ static void shade_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT) { + uic_mqtt_dotdot_shade_configuration_closed_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -5496,98 +5496,98 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS) { + uic_mqtt_dotdot_door_lock_door_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS) { + uic_mqtt_dotdot_door_lock_door_closed_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD) { + uic_mqtt_dotdot_door_lock_open_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5601,7 +5601,7 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5623,21 +5623,21 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS) { + uic_mqtt_dotdot_door_lock_led_settings_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME) { + uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME) { + uic_mqtt_dotdot_door_lock_sound_volume_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5700,14 +5700,14 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT) { + uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME) { + uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -5735,7 +5735,7 @@ static void door_lock_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT) { + uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6295,98 +6295,98 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS) { + uic_mqtt_dotdot_door_lock_door_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS) { + uic_mqtt_dotdot_door_lock_door_closed_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD) { + uic_mqtt_dotdot_door_lock_open_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_log_records_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_total_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_pin_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_rfid_users_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_week_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_year_day_schedules_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED) { + uic_mqtt_dotdot_door_lock_number_of_holiday_schedules_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_pin_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_max_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH) { + uic_mqtt_dotdot_door_lock_min_rfid_code_length_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6400,7 +6400,7 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER) { + uic_mqtt_dotdot_door_lock_number_of_credentials_supported_per_user_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6422,21 +6422,21 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS) { + uic_mqtt_dotdot_door_lock_led_settings_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME) { + uic_mqtt_dotdot_door_lock_auto_relock_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME) { + uic_mqtt_dotdot_door_lock_sound_volume_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6499,14 +6499,14 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT) { + uic_mqtt_dotdot_door_lock_wrong_code_entry_limit_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME) { + uic_mqtt_dotdot_door_lock_user_code_temporary_disable_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6534,7 +6534,7 @@ static void door_lock_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT) { + uic_mqtt_dotdot_door_lock_expiring_user_timeout_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -6726,42 +6726,42 @@ static void window_covering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT) { + uic_mqtt_dotdot_window_covering_current_position_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT) { + uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6775,63 +6775,63 @@ static void window_covering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT) { + uic_mqtt_dotdot_window_covering_velocity_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6846,7 +6846,7 @@ static void window_covering_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -6854,7 +6854,7 @@ static void window_covering_cluster_publish_desired_value_callback( + std::vector str_desired = attr.desired_or_reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + base_topic.c_str(), +- static_cast(str_desired.data()), ++ static_cast(str_desired.data()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7106,42 +7106,42 @@ static void window_covering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_physical_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT) { + uic_mqtt_dotdot_window_covering_current_position_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT) { + uic_mqtt_dotdot_window_covering_current_position_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT) { + uic_mqtt_dotdot_window_covering_number_of_actuations_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7155,63 +7155,63 @@ static void window_covering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_lift_percentage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE) { + uic_mqtt_dotdot_window_covering_current_position_tilt_percentage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_open_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT) { + uic_mqtt_dotdot_window_covering_installed_closed_limit_tilt_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT) { + uic_mqtt_dotdot_window_covering_velocity_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_acceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT) { + uic_mqtt_dotdot_window_covering_deceleration_time_lift_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7226,7 +7226,7 @@ static void window_covering_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_lift_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7234,7 +7234,7 @@ static void window_covering_cluster_publish_reported_value_callback( + std::vector str_desired = attr.reported>(); + uic_mqtt_dotdot_window_covering_intermediate_setpoints_tilt_publish( + base_topic.c_str(), +- static_cast( str_desired.data() ), ++ static_cast( str_desired.data() ), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7377,49 +7377,49 @@ static void barrier_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_close_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_open_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_close_events_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD) { + uic_mqtt_dotdot_barrier_control_open_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD) { + uic_mqtt_dotdot_barrier_control_close_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION) { + uic_mqtt_dotdot_barrier_control_barrier_position_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7605,49 +7605,49 @@ static void barrier_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_close_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_open_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS) { + uic_mqtt_dotdot_barrier_control_command_close_events_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD) { + uic_mqtt_dotdot_barrier_control_open_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD) { + uic_mqtt_dotdot_barrier_control_close_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION) { + uic_mqtt_dotdot_barrier_control_barrier_position_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -7776,14 +7776,14 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7818,28 +7818,28 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -7888,28 +7888,28 @@ static void pump_configuration_and_control_cluster_publish_desired_value_callbac + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER) { + uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8214,14 +8214,14 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8256,28 +8256,28 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_min_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW) { + uic_mqtt_dotdot_pump_configuration_and_control_max_const_flow_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8326,28 +8326,28 @@ static void pump_configuration_and_control_cluster_publish_reported_value_callba + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED) { + uic_mqtt_dotdot_pump_configuration_and_control_speed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_running_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER) { + uic_mqtt_dotdot_pump_configuration_and_control_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED) { + uic_mqtt_dotdot_pump_configuration_and_control_lifetime_energy_consumed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -8539,14 +8539,14 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8672,14 +8672,14 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8693,7 +8693,7 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION) { + uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8728,56 +8728,56 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP) { + uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_occupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA) { + uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -8791,7 +8791,7 @@ static void thermostat_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY) { + uic_mqtt_dotdot_thermostat_ac_capacity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -9367,14 +9367,14 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_cooling_demand_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND) { + uic_mqtt_dotdot_thermostat_pi_heating_demand_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9500,14 +9500,14 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_weekly_transitions_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS) { + uic_mqtt_dotdot_thermostat_number_of_daily_transitions_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9521,7 +9521,7 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION) { + uic_mqtt_dotdot_thermostat_temperature_setpoint_hold_duration_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9556,56 +9556,56 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP) { + uic_mqtt_dotdot_thermostat_setpoint_change_source_timestamp_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_occupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_occupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_occupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX) { + uic_mqtt_dotdot_thermostat_unoccupied_setback_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA) { + uic_mqtt_dotdot_thermostat_emergency_heat_delta_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -9619,7 +9619,7 @@ static void thermostat_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY) { + uic_mqtt_dotdot_thermostat_ac_capacity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10020,21 +10020,21 @@ static void dehumidification_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY) { + uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT) { + uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10055,14 +10055,14 @@ static void dehumidification_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10218,21 +10218,21 @@ static void dehumidification_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY) { + uic_mqtt_dotdot_dehumidification_control_relative_humidity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_cooling_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT) { + uic_mqtt_dotdot_dehumidification_control_rh_dehumidification_setpoint_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10253,14 +10253,14 @@ static void dehumidification_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_hysteresis_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL) { + uic_mqtt_dotdot_dehumidification_control_dehumidification_max_cool_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -10648,35 +10648,35 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION) { + uic_mqtt_dotdot_color_control_current_saturation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME) { + uic_mqtt_dotdot_color_control_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX) { + uic_mqtt_dotdot_color_control_currentx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY) { + uic_mqtt_dotdot_color_control_currenty_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10698,7 +10698,7 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10719,217 +10719,217 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES) { + uic_mqtt_dotdot_color_control_number_of_primaries_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X) { + uic_mqtt_dotdot_color_control_primary1x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y) { + uic_mqtt_dotdot_color_control_primary1y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY) { + uic_mqtt_dotdot_color_control_primary1_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X) { + uic_mqtt_dotdot_color_control_primary2x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y) { + uic_mqtt_dotdot_color_control_primary2y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY) { + uic_mqtt_dotdot_color_control_primary2_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X) { + uic_mqtt_dotdot_color_control_primary3x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y) { + uic_mqtt_dotdot_color_control_primary3y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY) { + uic_mqtt_dotdot_color_control_primary3_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X) { + uic_mqtt_dotdot_color_control_primary4x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y) { + uic_mqtt_dotdot_color_control_primary4y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY) { + uic_mqtt_dotdot_color_control_primary4_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X) { + uic_mqtt_dotdot_color_control_primary5x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y) { + uic_mqtt_dotdot_color_control_primary5y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY) { + uic_mqtt_dotdot_color_control_primary5_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X) { + uic_mqtt_dotdot_color_control_primary6x_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y) { + uic_mqtt_dotdot_color_control_primary6y_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY) { + uic_mqtt_dotdot_color_control_primary6_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX) { + uic_mqtt_dotdot_color_control_white_pointx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY) { + uic_mqtt_dotdot_color_control_white_pointy_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX) { + uic_mqtt_dotdot_color_control_color_pointrx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY) { + uic_mqtt_dotdot_color_control_color_pointry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX) { + uic_mqtt_dotdot_color_control_color_pointgx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY) { + uic_mqtt_dotdot_color_control_color_pointgy_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX) { + uic_mqtt_dotdot_color_control_color_pointbx_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY) { + uic_mqtt_dotdot_color_control_color_pointby_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10943,35 +10943,35 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE) { + uic_mqtt_dotdot_color_control_color_loop_active_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION) { + uic_mqtt_dotdot_color_control_color_loop_direction_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME) { + uic_mqtt_dotdot_color_control_color_loop_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -10985,28 +10985,28 @@ static void color_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -11507,35 +11507,35 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION) { + uic_mqtt_dotdot_color_control_current_saturation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME) { + uic_mqtt_dotdot_color_control_remaining_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX) { + uic_mqtt_dotdot_color_control_currentx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY) { + uic_mqtt_dotdot_color_control_currenty_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11557,7 +11557,7 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11578,217 +11578,217 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES) { + uic_mqtt_dotdot_color_control_number_of_primaries_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X) { + uic_mqtt_dotdot_color_control_primary1x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y) { + uic_mqtt_dotdot_color_control_primary1y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY) { + uic_mqtt_dotdot_color_control_primary1_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X) { + uic_mqtt_dotdot_color_control_primary2x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y) { + uic_mqtt_dotdot_color_control_primary2y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY) { + uic_mqtt_dotdot_color_control_primary2_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X) { + uic_mqtt_dotdot_color_control_primary3x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y) { + uic_mqtt_dotdot_color_control_primary3y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY) { + uic_mqtt_dotdot_color_control_primary3_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X) { + uic_mqtt_dotdot_color_control_primary4x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y) { + uic_mqtt_dotdot_color_control_primary4y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY) { + uic_mqtt_dotdot_color_control_primary4_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X) { + uic_mqtt_dotdot_color_control_primary5x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y) { + uic_mqtt_dotdot_color_control_primary5y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY) { + uic_mqtt_dotdot_color_control_primary5_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X) { + uic_mqtt_dotdot_color_control_primary6x_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y) { + uic_mqtt_dotdot_color_control_primary6y_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY) { + uic_mqtt_dotdot_color_control_primary6_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX) { + uic_mqtt_dotdot_color_control_white_pointx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY) { + uic_mqtt_dotdot_color_control_white_pointy_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX) { + uic_mqtt_dotdot_color_control_color_pointrx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY) { + uic_mqtt_dotdot_color_control_color_pointry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointr_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX) { + uic_mqtt_dotdot_color_control_color_pointgx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY) { + uic_mqtt_dotdot_color_control_color_pointgy_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointg_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX) { + uic_mqtt_dotdot_color_control_color_pointbx_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY) { + uic_mqtt_dotdot_color_control_color_pointby_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY) { + uic_mqtt_dotdot_color_control_color_pointb_intensity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE) { + uic_mqtt_dotdot_color_control_enhanced_current_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11802,35 +11802,35 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE) { + uic_mqtt_dotdot_color_control_color_loop_active_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION) { + uic_mqtt_dotdot_color_control_color_loop_direction_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME) { + uic_mqtt_dotdot_color_control_color_loop_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_start_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE) { + uic_mqtt_dotdot_color_control_color_loop_stored_enhanced_hue_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11844,28 +11844,28 @@ static void color_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS) { + uic_mqtt_dotdot_color_control_color_temp_physical_max_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS) { + uic_mqtt_dotdot_color_control_couple_color_temp_to_level_min_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS) { + uic_mqtt_dotdot_color_control_start_up_color_temperature_mireds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -11987,14 +11987,14 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12008,49 +12008,49 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_min_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_max_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME) { + uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR) { + uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT) { + uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY) { + uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12073,14 +12073,14 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12094,7 +12094,7 @@ static void ballast_configuration_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12307,14 +12307,14 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_physical_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12328,49 +12328,49 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_min_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_max_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL) { + uic_mqtt_dotdot_ballast_configuration_power_on_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME) { + uic_mqtt_dotdot_ballast_configuration_power_on_fade_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR) { + uic_mqtt_dotdot_ballast_configuration_intrinsic_ballast_factor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT) { + uic_mqtt_dotdot_ballast_configuration_ballast_factor_adjustment_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY) { + uic_mqtt_dotdot_ballast_configuration_lamp_quantity_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12393,14 +12393,14 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_rated_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12414,7 +12414,7 @@ static void ballast_configuration_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT) { + uic_mqtt_dotdot_ballast_configuration_lamp_burn_hours_trip_point_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12536,28 +12536,28 @@ static void illuminance_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12689,28 +12689,28 @@ static void illuminance_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_illuminance_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_illuminance_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -12853,7 +12853,7 @@ static void illuminance_level_sensing_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL) { + uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -12976,7 +12976,7 @@ static void illuminance_level_sensing_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL) { + uic_mqtt_dotdot_illuminance_level_sensing_illuminance_target_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13119,7 +13119,7 @@ static void temperature_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13257,7 +13257,7 @@ static void temperature_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_temperature_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13400,7 +13400,7 @@ static void pressure_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13428,7 +13428,7 @@ static void pressure_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13613,7 +13613,7 @@ static void pressure_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13641,7 +13641,7 @@ static void pressure_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE) { + uic_mqtt_dotdot_pressure_measurement_scaled_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -13770,28 +13770,28 @@ static void flow_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_flow_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -13908,28 +13908,28 @@ static void flow_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_flow_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_flow_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14051,28 +14051,28 @@ static void relativity_humidity_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE) { + uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14189,28 +14189,28 @@ static void relativity_humidity_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_relativity_humidity_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE) { + uic_mqtt_dotdot_relativity_humidity_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14353,63 +14353,63 @@ static void occupancy_sensing_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14611,63 +14611,63 @@ static void occupancy_sensing_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD) { + uic_mqtt_dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -14789,28 +14789,28 @@ static void soil_moisture_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE) { + uic_mqtt_dotdot_soil_moisture_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -14927,28 +14927,28 @@ static void soil_moisture_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_soil_moisture_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE) { + uic_mqtt_dotdot_soil_moisture_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15070,28 +15070,28 @@ static void ph_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_ph_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15208,28 +15208,28 @@ static void ph_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_ph_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_ph_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15351,28 +15351,28 @@ static void electrical_conductivity_measurement_cluster_publish_desired_value_ca + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15489,28 +15489,28 @@ static void electrical_conductivity_measurement_cluster_publish_reported_value_c + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_electrical_conductivity_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -15632,28 +15632,28 @@ static void wind_speed_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -15770,28 +15770,28 @@ static void wind_speed_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_min_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE) { + uic_mqtt_dotdot_wind_speed_measurement_max_measured_value_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE) { + uic_mqtt_dotdot_wind_speed_measurement_tolerance_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -16784,21 +16784,21 @@ static void ias_zone_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID) { + uic_mqtt_dotdot_ias_zone_zoneid_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED) { + uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL) { + uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -16967,21 +16967,21 @@ static void ias_zone_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID) { + uic_mqtt_dotdot_ias_zone_zoneid_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED) { + uic_mqtt_dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL) { + uic_mqtt_dotdot_ias_zone_current_zone_sensitivity_level_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17103,7 +17103,7 @@ static void iaswd_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION) { + uic_mqtt_dotdot_iaswd_max_duration_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17196,7 +17196,7 @@ static void iaswd_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION) { + uic_mqtt_dotdot_iaswd_max_duration_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17318,21 +17318,21 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED) { + uic_mqtt_dotdot_metering_current_summation_delivered_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED) { + uic_mqtt_dotdot_metering_current_summation_received_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17353,28 +17353,28 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME) { + uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD) { + uic_mqtt_dotdot_metering_default_update_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17388,14 +17388,14 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17423,14 +17423,14 @@ static void metering_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER) { + uic_mqtt_dotdot_metering_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR) { + uic_mqtt_dotdot_metering_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -17786,21 +17786,21 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED) { + uic_mqtt_dotdot_metering_current_summation_delivered_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED) { + uic_mqtt_dotdot_metering_current_summation_received_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17821,28 +17821,28 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME) { + uic_mqtt_dotdot_metering_reading_snap_shot_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_delivered_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME) { + uic_mqtt_dotdot_metering_current_max_demand_received_time_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD) { + uic_mqtt_dotdot_metering_default_update_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17856,14 +17856,14 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_inlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION) { + uic_mqtt_dotdot_metering_current_outlet_energy_carrier_summation_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -17891,14 +17891,14 @@ static void metering_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER) { + uic_mqtt_dotdot_metering_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR) { + uic_mqtt_dotdot_metering_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -18153,70 +18153,70 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18237,7 +18237,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18328,28 +18328,28 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18370,7 +18370,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_line_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18391,42 +18391,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18461,7 +18461,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18475,91 +18475,91 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18664,7 +18664,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18685,42 +18685,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18755,7 +18755,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18769,56 +18769,56 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18839,42 +18839,42 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18909,7 +18909,7 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -18923,49 +18923,49 @@ static void electrical_measurement_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -20136,70 +20136,70 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_dc_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_dc_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_neutral_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20220,7 +20220,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_total_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20311,28 +20311,28 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_frequency_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20353,7 +20353,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_line_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20374,42 +20374,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT) { + uic_mqtt_dotdot_electrical_measurement_rms_current_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20444,7 +20444,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20458,91 +20458,91 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_voltage_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_current_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_current_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER) { + uic_mqtt_dotdot_electrical_measurement_ac_power_multiplier_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR) { + uic_mqtt_dotdot_electrical_measurement_ac_power_divisor_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20647,7 +20647,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_line_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20668,42 +20668,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20738,7 +20738,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20752,56 +20752,56 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phb_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_line_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20822,42 +20822,42 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_min_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_current_max_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20892,7 +20892,7 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC) { + uic_mqtt_dotdot_electrical_measurement_apparent_power_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -20906,49 +20906,49 @@ static void electrical_measurement_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC) { + uic_mqtt_dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_sag_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC) { + uic_mqtt_dotdot_electrical_measurement_rms_voltage_swell_period_phc_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -21070,217 +21070,217 @@ static void diagnostics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS) { + uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES) { + uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED) { + uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED) { + uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED) { + uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE) { + uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION) { + uic_mqtt_dotdot_diagnostics_join_indication_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED) { + uic_mqtt_dotdot_diagnostics_child_moved_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY) { + uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES) { + uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST) { + uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED) { + uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT) { + uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT) { + uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI) { + uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -21628,217 +21628,217 @@ static void diagnostics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS) { + uic_mqtt_dotdot_diagnostics_number_of_resets_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES) { + uic_mqtt_dotdot_diagnostics_persistent_memory_writes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_mac_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST) { + uic_mqtt_dotdot_diagnostics_aps_tx_bcast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST) { + uic_mqtt_dotdot_diagnostics_aps_rx_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_success_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_retry_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL) { + uic_mqtt_dotdot_diagnostics_aps_tx_ucast_fail_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED) { + uic_mqtt_dotdot_diagnostics_route_disc_initiated_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED) { + uic_mqtt_dotdot_diagnostics_neighbor_added_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED) { + uic_mqtt_dotdot_diagnostics_neighbor_removed_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE) { + uic_mqtt_dotdot_diagnostics_neighbor_stale_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION) { + uic_mqtt_dotdot_diagnostics_join_indication_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED) { + uic_mqtt_dotdot_diagnostics_child_moved_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_nwkfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE) { + uic_mqtt_dotdot_diagnostics_apsfc_failure_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY) { + uic_mqtt_dotdot_diagnostics_aps_unauthorized_key_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_nwk_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES) { + uic_mqtt_dotdot_diagnostics_aps_decrypt_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES) { + uic_mqtt_dotdot_diagnostics_packet_buffer_allocate_failures_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST) { + uic_mqtt_dotdot_diagnostics_relayed_ucast_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED) { + uic_mqtt_dotdot_diagnostics_phy_to_mac_queue_limit_reached_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT) { + uic_mqtt_dotdot_diagnostics_packet_validate_drop_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT) { + uic_mqtt_dotdot_diagnostics_average_mac_retry_per_aps_message_sent_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI) { + uic_mqtt_dotdot_diagnostics_last_messagelqi_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -22202,7 +22202,7 @@ static void state_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY) { + uic_mqtt_dotdot_state_maximum_command_delay_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22342,7 +22342,7 @@ static void state_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY) { + uic_mqtt_dotdot_state_maximum_command_delay_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -22701,7 +22701,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22800,7 +22800,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES) { + uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -22849,7 +22849,7 @@ static void system_metrics_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS) { + uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23145,7 +23145,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_system_metrics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23244,7 +23244,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES) { + uic_mqtt_dotdot_system_metrics_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23293,7 +23293,7 @@ static void system_metrics_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS) { + uic_mqtt_dotdot_system_metrics_system_interrupts_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23432,14 +23432,14 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES) { + uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID) { + uic_mqtt_dotdot_application_monitoring_process_id_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23476,28 +23476,28 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT) { + uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23525,7 +23525,7 @@ static void application_monitoring_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -23850,14 +23850,14 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES) { + uic_mqtt_dotdot_application_monitoring_uptime_minutes_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID) { + uic_mqtt_dotdot_application_monitoring_process_id_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23894,28 +23894,28 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_sent_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED) { + uic_mqtt_dotdot_application_monitoring_mqtt_messages_received_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT) { + uic_mqtt_dotdot_application_monitoring_mqtt_subscription_count_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -23943,7 +23943,7 @@ static void application_monitoring_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS) { + uic_mqtt_dotdot_application_monitoring_application_statistics_reporting_interval_seconds_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -24544,7 +24544,7 @@ static void user_credential_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS) { + uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -24743,7 +24743,7 @@ static void user_credential_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS) { + uic_mqtt_dotdot_user_credential_supported_user_unique_identifiers_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -25889,7 +25889,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -25924,7 +25924,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -25959,7 +25959,7 @@ static void unify_humidity_control_cluster_publish_desired_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.desired_or_reported()), ++ static_cast(attr.desired_or_reported()), + UCL_MQTT_PUBLISH_TYPE_DESIRED); + return; + } +@@ -26252,7 +26252,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_humidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -26287,7 +26287,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_dehumidifier_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +@@ -26322,7 +26322,7 @@ static void unify_humidity_control_cluster_publish_reported_value_callback( + if (type == DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION) { + uic_mqtt_dotdot_unify_humidity_control_auto_setpoint_precision_publish( + base_topic.c_str(), +- static_cast(attr.reported()), ++ static_cast(attr.reported()), + (attr.desired_exists() && !attribute_store_is_value_matched(updated_node)) ? UCL_MQTT_PUBLISH_TYPE_REPORTED : UCL_MQTT_PUBLISH_TYPE_ALL); + return; + } +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp +index 0b8fc63e13..ba326df8ab 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_helpers.cpp +@@ -40,7 +40,7 @@ bool dotdot_is_supported_basic_zcl_version( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_basic_zcl_version( ++uint8_t dotdot_get_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -51,7 +51,7 @@ int8_t dotdot_get_basic_zcl_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_ZCL_VERSION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -63,7 +63,7 @@ sl_status_t dotdot_set_basic_zcl_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_zcl_version ++ uint8_t new_zcl_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -76,7 +76,7 @@ sl_status_t dotdot_set_basic_zcl_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_zcl_version, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_basic_zcl_version_undefine_reported( +@@ -151,7 +151,7 @@ bool dotdot_is_supported_basic_application_version( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_basic_application_version( ++uint8_t dotdot_get_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -162,7 +162,7 @@ int8_t dotdot_get_basic_application_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_APPLICATION_VERSION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -174,7 +174,7 @@ sl_status_t dotdot_set_basic_application_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_application_version ++ uint8_t new_application_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -187,7 +187,7 @@ sl_status_t dotdot_set_basic_application_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_application_version, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_basic_application_version_undefine_reported( +@@ -262,7 +262,7 @@ bool dotdot_is_supported_basic_stack_version( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_basic_stack_version( ++uint8_t dotdot_get_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -273,7 +273,7 @@ int8_t dotdot_get_basic_stack_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_STACK_VERSION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -285,7 +285,7 @@ sl_status_t dotdot_set_basic_stack_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_stack_version ++ uint8_t new_stack_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -298,7 +298,7 @@ sl_status_t dotdot_set_basic_stack_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_stack_version, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_basic_stack_version_undefine_reported( +@@ -373,7 +373,7 @@ bool dotdot_is_supported_basic_hw_version( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_basic_hw_version( ++uint8_t dotdot_get_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -384,7 +384,7 @@ int8_t dotdot_get_basic_hw_version( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BASIC_HW_VERSION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -396,7 +396,7 @@ sl_status_t dotdot_set_basic_hw_version( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_hw_version ++ uint8_t new_hw_version + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -409,7 +409,7 @@ sl_status_t dotdot_set_basic_hw_version( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_hw_version, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_basic_hw_version_undefine_reported( +@@ -1153,7 +1153,7 @@ bool dotdot_is_supported_basic_product_code( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_basic_product_code( ++const char* dotdot_get_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -1176,7 +1176,7 @@ sl_status_t dotdot_set_basic_product_code( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_product_code ++ const char* new_product_code + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2478,7 +2478,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_mains_voltage( ++uint16_t dotdot_get_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2489,7 +2489,7 @@ int16_t dotdot_get_power_configuration_mains_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2501,7 +2501,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage ++ uint16_t new_mains_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2514,7 +2514,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_undefine_reported( +@@ -2589,7 +2589,7 @@ bool dotdot_is_supported_power_configuration_mains_frequency( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_mains_frequency( ++uint8_t dotdot_get_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2600,7 +2600,7 @@ int8_t dotdot_get_power_configuration_mains_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_FREQUENCY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2612,7 +2612,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_mains_frequency ++ uint8_t new_mains_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2625,7 +2625,7 @@ sl_status_t dotdot_set_power_configuration_mains_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_frequency, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_mains_frequency_undefine_reported( +@@ -2811,7 +2811,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_mains_voltage_min_threshold( ++uint16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2822,7 +2822,7 @@ int16_t dotdot_get_power_configuration_mains_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MIN_THRESHOLD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2834,7 +2834,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_min_threshold ++ uint16_t new_mains_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2847,7 +2847,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_min_threshold, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_min_threshold_undefine_reported( +@@ -2922,7 +2922,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_max_threshold( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_mains_voltage_max_threshold( ++uint16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -2933,7 +2933,7 @@ int16_t dotdot_get_power_configuration_mains_voltage_max_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_MAX_THRESHOLD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -2945,7 +2945,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_max_threshold ++ uint16_t new_mains_voltage_max_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -2958,7 +2958,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_max_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_max_threshold, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_max_threshold_undefine_reported( +@@ -3033,7 +3033,7 @@ bool dotdot_is_supported_power_configuration_mains_voltage_dwell_trip_point( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( ++uint16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3044,7 +3044,7 @@ int16_t dotdot_get_power_configuration_mains_voltage_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_MAINS_VOLTAGE_DWELL_TRIP_POINT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3056,7 +3056,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mains_voltage_dwell_trip_point ++ uint16_t new_mains_voltage_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3069,7 +3069,7 @@ sl_status_t dotdot_set_power_configuration_mains_voltage_dwell_trip_point( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mains_voltage_dwell_trip_point, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_mains_voltage_dwell_trip_point_undefine_reported( +@@ -3144,7 +3144,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_voltage( ++uint8_t dotdot_get_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3155,7 +3155,7 @@ int8_t dotdot_get_power_configuration_battery_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3167,7 +3167,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage ++ uint8_t new_battery_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3180,7 +3180,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_undefine_reported( +@@ -3255,7 +3255,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_remaining( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3266,7 +3266,7 @@ int8_t dotdot_get_power_configuration_battery_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_REMAINING); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3278,7 +3278,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_remaining ++ uint8_t new_battery_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3291,7 +3291,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_remaining, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_remaining_undefine_reported( +@@ -3589,7 +3589,7 @@ bool dotdot_is_supported_power_configuration_batterya_hr_rating( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_batterya_hr_rating( ++uint16_t dotdot_get_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3600,7 +3600,7 @@ int16_t dotdot_get_power_configuration_batterya_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERYA_HR_RATING); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3612,7 +3612,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_batterya_hr_rating ++ uint16_t new_batterya_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3625,7 +3625,7 @@ sl_status_t dotdot_set_power_configuration_batterya_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_batterya_hr_rating, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_batterya_hr_rating_undefine_reported( +@@ -3700,7 +3700,7 @@ bool dotdot_is_supported_power_configuration_battery_quantity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_quantity( ++uint8_t dotdot_get_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3711,7 +3711,7 @@ int8_t dotdot_get_power_configuration_battery_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_QUANTITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3723,7 +3723,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_quantity ++ uint8_t new_battery_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3736,7 +3736,7 @@ sl_status_t dotdot_set_power_configuration_battery_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_quantity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_quantity_undefine_reported( +@@ -3811,7 +3811,7 @@ bool dotdot_is_supported_power_configuration_battery_rated_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -3822,7 +3822,7 @@ int8_t dotdot_get_power_configuration_battery_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_RATED_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -3834,7 +3834,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_rated_voltage ++ uint8_t new_battery_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -3847,7 +3847,7 @@ sl_status_t dotdot_set_power_configuration_battery_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_rated_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_rated_voltage_undefine_reported( +@@ -4033,7 +4033,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4044,7 +4044,7 @@ int8_t dotdot_get_power_configuration_battery_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4056,7 +4056,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_min_threshold ++ uint8_t new_battery_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4069,7 +4069,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_min_threshold_undefine_reported( +@@ -4144,7 +4144,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4155,7 +4155,7 @@ int8_t dotdot_get_power_configuration_battery_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4167,7 +4167,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold1 ++ uint8_t new_battery_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4180,7 +4180,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold1_undefine_reported( +@@ -4255,7 +4255,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4266,7 +4266,7 @@ int8_t dotdot_get_power_configuration_battery_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4278,7 +4278,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold2 ++ uint8_t new_battery_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4291,7 +4291,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold2_undefine_reported( +@@ -4366,7 +4366,7 @@ bool dotdot_is_supported_power_configuration_battery_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4377,7 +4377,7 @@ int8_t dotdot_get_power_configuration_battery_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_VOLTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4389,7 +4389,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_voltage_threshold3 ++ uint8_t new_battery_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4402,7 +4402,7 @@ sl_status_t dotdot_set_power_configuration_battery_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_voltage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_voltage_threshold3_undefine_reported( +@@ -4477,7 +4477,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4488,7 +4488,7 @@ int8_t dotdot_get_power_configuration_battery_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4500,7 +4500,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_min_threshold ++ uint8_t new_battery_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4513,7 +4513,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_min_threshold_undefine_reported( +@@ -4588,7 +4588,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4599,7 +4599,7 @@ int8_t dotdot_get_power_configuration_battery_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4611,7 +4611,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold1 ++ uint8_t new_battery_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4624,7 +4624,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold1_undefine_reported( +@@ -4699,7 +4699,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4710,7 +4710,7 @@ int8_t dotdot_get_power_configuration_battery_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4722,7 +4722,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold2 ++ uint8_t new_battery_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4735,7 +4735,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold2_undefine_reported( +@@ -4810,7 +4810,7 @@ bool dotdot_is_supported_power_configuration_battery_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -4821,7 +4821,7 @@ int8_t dotdot_get_power_configuration_battery_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY_PERCENTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -4833,7 +4833,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery_percentage_threshold3 ++ uint8_t new_battery_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -4846,7 +4846,7 @@ sl_status_t dotdot_set_power_configuration_battery_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery_percentage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery_percentage_threshold3_undefine_reported( +@@ -5032,7 +5032,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_voltage( ++uint8_t dotdot_get_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5043,7 +5043,7 @@ int8_t dotdot_get_power_configuration_battery2_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5055,7 +5055,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage ++ uint8_t new_battery2_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5068,7 +5068,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_undefine_reported( +@@ -5143,7 +5143,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_remaining( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5154,7 +5154,7 @@ int8_t dotdot_get_power_configuration_battery2_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_REMAINING); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5166,7 +5166,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_remaining ++ uint8_t new_battery2_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5179,7 +5179,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_remaining, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_remaining_undefine_reported( +@@ -5477,7 +5477,7 @@ bool dotdot_is_supported_power_configuration_battery2a_hr_rating( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_battery2a_hr_rating( ++uint16_t dotdot_get_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5488,7 +5488,7 @@ int16_t dotdot_get_power_configuration_battery2a_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2A_HR_RATING); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5500,7 +5500,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_battery2a_hr_rating ++ uint16_t new_battery2a_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5513,7 +5513,7 @@ sl_status_t dotdot_set_power_configuration_battery2a_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2a_hr_rating, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_battery2a_hr_rating_undefine_reported( +@@ -5588,7 +5588,7 @@ bool dotdot_is_supported_power_configuration_battery2_quantity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_quantity( ++uint8_t dotdot_get_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5599,7 +5599,7 @@ int8_t dotdot_get_power_configuration_battery2_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_QUANTITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5611,7 +5611,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_quantity ++ uint8_t new_battery2_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5624,7 +5624,7 @@ sl_status_t dotdot_set_power_configuration_battery2_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_quantity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_quantity_undefine_reported( +@@ -5699,7 +5699,7 @@ bool dotdot_is_supported_power_configuration_battery2_rated_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5710,7 +5710,7 @@ int8_t dotdot_get_power_configuration_battery2_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_RATED_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5722,7 +5722,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_rated_voltage ++ uint8_t new_battery2_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5735,7 +5735,7 @@ sl_status_t dotdot_set_power_configuration_battery2_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_rated_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_rated_voltage_undefine_reported( +@@ -5921,7 +5921,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -5932,7 +5932,7 @@ int8_t dotdot_get_power_configuration_battery2_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -5944,7 +5944,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_min_threshold ++ uint8_t new_battery2_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -5957,7 +5957,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_min_threshold_undefine_reported( +@@ -6032,7 +6032,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6043,7 +6043,7 @@ int8_t dotdot_get_power_configuration_battery2_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6055,7 +6055,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold1 ++ uint8_t new_battery2_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6068,7 +6068,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold1_undefine_reported( +@@ -6143,7 +6143,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6154,7 +6154,7 @@ int8_t dotdot_get_power_configuration_battery2_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6166,7 +6166,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold2 ++ uint8_t new_battery2_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6179,7 +6179,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold2_undefine_reported( +@@ -6254,7 +6254,7 @@ bool dotdot_is_supported_power_configuration_battery2_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6265,7 +6265,7 @@ int8_t dotdot_get_power_configuration_battery2_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_VOLTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6277,7 +6277,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_voltage_threshold3 ++ uint8_t new_battery2_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6290,7 +6290,7 @@ sl_status_t dotdot_set_power_configuration_battery2_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_voltage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_voltage_threshold3_undefine_reported( +@@ -6365,7 +6365,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6376,7 +6376,7 @@ int8_t dotdot_get_power_configuration_battery2_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6388,7 +6388,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_min_threshold ++ uint8_t new_battery2_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6401,7 +6401,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_min_threshold_undefine_reported( +@@ -6476,7 +6476,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6487,7 +6487,7 @@ int8_t dotdot_get_power_configuration_battery2_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6499,7 +6499,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold1 ++ uint8_t new_battery2_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6512,7 +6512,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold1_undefine_reported( +@@ -6587,7 +6587,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6598,7 +6598,7 @@ int8_t dotdot_get_power_configuration_battery2_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6610,7 +6610,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold2 ++ uint8_t new_battery2_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6623,7 +6623,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold2_undefine_reported( +@@ -6698,7 +6698,7 @@ bool dotdot_is_supported_power_configuration_battery2_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery2_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6709,7 +6709,7 @@ int8_t dotdot_get_power_configuration_battery2_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY2_PERCENTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6721,7 +6721,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery2_percentage_threshold3 ++ uint8_t new_battery2_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6734,7 +6734,7 @@ sl_status_t dotdot_set_power_configuration_battery2_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery2_percentage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery2_percentage_threshold3_undefine_reported( +@@ -6920,7 +6920,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_voltage( ++uint8_t dotdot_get_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -6931,7 +6931,7 @@ int8_t dotdot_get_power_configuration_battery3_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -6943,7 +6943,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage ++ uint8_t new_battery3_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -6956,7 +6956,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_undefine_reported( +@@ -7031,7 +7031,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_remaining( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_percentage_remaining( ++uint8_t dotdot_get_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7042,7 +7042,7 @@ int8_t dotdot_get_power_configuration_battery3_percentage_remaining( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_REMAINING); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7054,7 +7054,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_remaining ++ uint8_t new_battery3_percentage_remaining + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7067,7 +7067,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_remaining( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_remaining, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_remaining_undefine_reported( +@@ -7365,7 +7365,7 @@ bool dotdot_is_supported_power_configuration_battery3a_hr_rating( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_power_configuration_battery3a_hr_rating( ++uint16_t dotdot_get_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7376,7 +7376,7 @@ int16_t dotdot_get_power_configuration_battery3a_hr_rating( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3A_HR_RATING); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7388,7 +7388,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_battery3a_hr_rating ++ uint16_t new_battery3a_hr_rating + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7401,7 +7401,7 @@ sl_status_t dotdot_set_power_configuration_battery3a_hr_rating( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3a_hr_rating, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_power_configuration_battery3a_hr_rating_undefine_reported( +@@ -7476,7 +7476,7 @@ bool dotdot_is_supported_power_configuration_battery3_quantity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_quantity( ++uint8_t dotdot_get_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7487,7 +7487,7 @@ int8_t dotdot_get_power_configuration_battery3_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_QUANTITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7499,7 +7499,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_quantity ++ uint8_t new_battery3_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7512,7 +7512,7 @@ sl_status_t dotdot_set_power_configuration_battery3_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_quantity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_quantity_undefine_reported( +@@ -7587,7 +7587,7 @@ bool dotdot_is_supported_power_configuration_battery3_rated_voltage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_rated_voltage( ++uint8_t dotdot_get_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7598,7 +7598,7 @@ int8_t dotdot_get_power_configuration_battery3_rated_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_RATED_VOLTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7610,7 +7610,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_rated_voltage ++ uint8_t new_battery3_rated_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7623,7 +7623,7 @@ sl_status_t dotdot_set_power_configuration_battery3_rated_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_rated_voltage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_rated_voltage_undefine_reported( +@@ -7809,7 +7809,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7820,7 +7820,7 @@ int8_t dotdot_get_power_configuration_battery3_voltage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7832,7 +7832,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_min_threshold ++ uint8_t new_battery3_voltage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7845,7 +7845,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_min_threshold_undefine_reported( +@@ -7920,7 +7920,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold1( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -7931,7 +7931,7 @@ int8_t dotdot_get_power_configuration_battery3_voltage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -7943,7 +7943,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold1 ++ uint8_t new_battery3_voltage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -7956,7 +7956,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold1_undefine_reported( +@@ -8031,7 +8031,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold2( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8042,7 +8042,7 @@ int8_t dotdot_get_power_configuration_battery3_voltage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8054,7 +8054,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold2 ++ uint8_t new_battery3_voltage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8067,7 +8067,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold2_undefine_reported( +@@ -8142,7 +8142,7 @@ bool dotdot_is_supported_power_configuration_battery3_voltage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_voltage_threshold3( ++uint8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8153,7 +8153,7 @@ int8_t dotdot_get_power_configuration_battery3_voltage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_VOLTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8165,7 +8165,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_voltage_threshold3 ++ uint8_t new_battery3_voltage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8178,7 +8178,7 @@ sl_status_t dotdot_set_power_configuration_battery3_voltage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_voltage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_voltage_threshold3_undefine_reported( +@@ -8253,7 +8253,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_min_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( ++uint8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8264,7 +8264,7 @@ int8_t dotdot_get_power_configuration_battery3_percentage_min_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_MIN_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8276,7 +8276,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_min_threshold ++ uint8_t new_battery3_percentage_min_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8289,7 +8289,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_min_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_min_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_min_threshold_undefine_reported( +@@ -8364,7 +8364,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold1( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold1( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8375,7 +8375,7 @@ int8_t dotdot_get_power_configuration_battery3_percentage_threshold1( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD1); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8387,7 +8387,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold1 ++ uint8_t new_battery3_percentage_threshold1 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8400,7 +8400,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold1( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold1, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold1_undefine_reported( +@@ -8475,7 +8475,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold2( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold2( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8486,7 +8486,7 @@ int8_t dotdot_get_power_configuration_battery3_percentage_threshold2( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD2); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8498,7 +8498,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold2 ++ uint8_t new_battery3_percentage_threshold2 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8511,7 +8511,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold2( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold2, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold2_undefine_reported( +@@ -8586,7 +8586,7 @@ bool dotdot_is_supported_power_configuration_battery3_percentage_threshold3( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_power_configuration_battery3_percentage_threshold3( ++uint8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -8597,7 +8597,7 @@ int8_t dotdot_get_power_configuration_battery3_percentage_threshold3( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POWER_CONFIGURATION_BATTERY3_PERCENTAGE_THRESHOLD3); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -8609,7 +8609,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_battery3_percentage_threshold3 ++ uint8_t new_battery3_percentage_threshold3 + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -8622,7 +8622,7 @@ sl_status_t dotdot_set_power_configuration_battery3_percentage_threshold3( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_battery3_percentage_threshold3, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_power_configuration_battery3_percentage_threshold3_undefine_reported( +@@ -9469,7 +9469,7 @@ bool dotdot_is_supported_device_temperature_configuration_over_temp_total_dwell( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( ++uint16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -9480,7 +9480,7 @@ int16_t dotdot_get_device_temperature_configuration_over_temp_total_dwell( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_OVER_TEMP_TOTAL_DWELL); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -9492,7 +9492,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_over_temp_total_dwell ++ uint16_t new_over_temp_total_dwell + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -9505,7 +9505,7 @@ sl_status_t dotdot_set_device_temperature_configuration_over_temp_total_dwell( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_over_temp_total_dwell, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_device_temperature_configuration_over_temp_total_dwell_undefine_reported( +@@ -9913,7 +9913,7 @@ bool dotdot_is_supported_device_temperature_configuration_low_temp_dwell_trip_po + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( ++uint32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -9924,7 +9924,7 @@ int32_t dotdot_get_device_temperature_configuration_low_temp_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_LOW_TEMP_DWELL_TRIP_POINT); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -9936,7 +9936,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_low_temp_dwell_trip_point ++ uint32_t new_low_temp_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -9949,7 +9949,7 @@ sl_status_t dotdot_set_device_temperature_configuration_low_temp_dwell_trip_poin + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_low_temp_dwell_trip_point, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_device_temperature_configuration_low_temp_dwell_trip_point_undefine_reported( +@@ -10024,7 +10024,7 @@ bool dotdot_is_supported_device_temperature_configuration_high_temp_dwell_trip_p + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( ++uint32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10035,7 +10035,7 @@ int32_t dotdot_get_device_temperature_configuration_high_temp_dwell_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEVICE_TEMPERATURE_CONFIGURATION_HIGH_TEMP_DWELL_TRIP_POINT); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10047,7 +10047,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_high_temp_dwell_trip_point ++ uint32_t new_high_temp_dwell_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10060,7 +10060,7 @@ sl_status_t dotdot_set_device_temperature_configuration_high_temp_dwell_trip_poi + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_high_temp_dwell_trip_point, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_device_temperature_configuration_high_temp_dwell_trip_point_undefine_reported( +@@ -10196,7 +10196,7 @@ bool dotdot_is_supported_identify_identify_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_identify_identify_time( ++uint16_t dotdot_get_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10207,7 +10207,7 @@ int16_t dotdot_get_identify_identify_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IDENTIFY_IDENTIFY_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10219,7 +10219,7 @@ sl_status_t dotdot_set_identify_identify_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_identify_time ++ uint16_t new_identify_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10232,7 +10232,7 @@ sl_status_t dotdot_set_identify_identify_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_identify_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_identify_identify_time_undefine_reported( +@@ -10465,7 +10465,7 @@ bool dotdot_is_supported_scenes_scene_count( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_scenes_scene_count( ++uint8_t dotdot_get_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10476,7 +10476,7 @@ int8_t dotdot_get_scenes_scene_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_SCENE_COUNT); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10488,7 +10488,7 @@ sl_status_t dotdot_set_scenes_scene_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_scene_count ++ uint8_t new_scene_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10501,7 +10501,7 @@ sl_status_t dotdot_set_scenes_scene_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_scene_count, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_scenes_scene_count_undefine_reported( +@@ -10576,7 +10576,7 @@ bool dotdot_is_supported_scenes_current_scene( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_scenes_current_scene( ++uint8_t dotdot_get_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10587,7 +10587,7 @@ int8_t dotdot_get_scenes_current_scene( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_SCENE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10599,7 +10599,7 @@ sl_status_t dotdot_set_scenes_current_scene( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_scene ++ uint8_t new_current_scene + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10612,7 +10612,7 @@ sl_status_t dotdot_set_scenes_current_scene( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_scene, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_scenes_current_scene_undefine_reported( +@@ -10687,7 +10687,7 @@ bool dotdot_is_supported_scenes_current_group( + return attribute_store_node_exists(node); + } + +-uint8_t * dotdot_get_scenes_current_group( ++uint16_t dotdot_get_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -10698,7 +10698,7 @@ uint8_t * dotdot_get_scenes_current_group( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SCENES_CURRENT_GROUP); + +- uint8_t * result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -10710,7 +10710,7 @@ sl_status_t dotdot_set_scenes_current_group( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t * new_current_group ++ uint16_t new_current_group + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -10723,7 +10723,7 @@ sl_status_t dotdot_set_scenes_current_group( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_group, +- sizeof(uint8_t *)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_scenes_current_group_undefine_reported( +@@ -11507,7 +11507,7 @@ bool dotdot_is_supported_on_off_on_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_on_off_on_time( ++uint16_t dotdot_get_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11518,7 +11518,7 @@ int16_t dotdot_get_on_off_on_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ON_OFF_ON_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11530,7 +11530,7 @@ sl_status_t dotdot_set_on_off_on_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_time ++ uint16_t new_on_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11543,7 +11543,7 @@ sl_status_t dotdot_set_on_off_on_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_on_off_on_time_undefine_reported( +@@ -11618,7 +11618,7 @@ bool dotdot_is_supported_on_off_off_wait_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_on_off_off_wait_time( ++uint16_t dotdot_get_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11629,7 +11629,7 @@ int16_t dotdot_get_on_off_off_wait_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ON_OFF_OFF_WAIT_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11641,7 +11641,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_off_wait_time ++ uint16_t new_off_wait_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11654,7 +11654,7 @@ sl_status_t dotdot_set_on_off_off_wait_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_off_wait_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_on_off_off_wait_time_undefine_reported( +@@ -11883,7 +11883,7 @@ bool dotdot_is_supported_level_current_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_level_current_level( ++uint8_t dotdot_get_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -11894,7 +11894,7 @@ int8_t dotdot_get_level_current_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -11906,7 +11906,7 @@ sl_status_t dotdot_set_level_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_level ++ uint8_t new_current_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -11919,7 +11919,7 @@ sl_status_t dotdot_set_level_current_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_level_current_level_undefine_reported( +@@ -11994,7 +11994,7 @@ bool dotdot_is_supported_level_remaining_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_remaining_time( ++uint16_t dotdot_get_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12005,7 +12005,7 @@ int16_t dotdot_get_level_remaining_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_REMAINING_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12017,7 +12017,7 @@ sl_status_t dotdot_set_level_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_remaining_time ++ uint16_t new_remaining_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12030,7 +12030,7 @@ sl_status_t dotdot_set_level_remaining_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_remaining_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_remaining_time_undefine_reported( +@@ -12105,7 +12105,7 @@ bool dotdot_is_supported_level_min_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_level_min_level( ++uint8_t dotdot_get_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12116,7 +12116,7 @@ int8_t dotdot_get_level_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12128,7 +12128,7 @@ sl_status_t dotdot_set_level_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_level ++ uint8_t new_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12141,7 +12141,7 @@ sl_status_t dotdot_set_level_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_level_min_level_undefine_reported( +@@ -12216,7 +12216,7 @@ bool dotdot_is_supported_level_max_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_level_max_level( ++uint8_t dotdot_get_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12227,7 +12227,7 @@ int8_t dotdot_get_level_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12239,7 +12239,7 @@ sl_status_t dotdot_set_level_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_level ++ uint8_t new_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12252,7 +12252,7 @@ sl_status_t dotdot_set_level_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_level_max_level_undefine_reported( +@@ -12327,7 +12327,7 @@ bool dotdot_is_supported_level_current_frequency( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_current_frequency( ++uint16_t dotdot_get_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12338,7 +12338,7 @@ int16_t dotdot_get_level_current_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_CURRENT_FREQUENCY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12350,7 +12350,7 @@ sl_status_t dotdot_set_level_current_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_frequency ++ uint16_t new_current_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12363,7 +12363,7 @@ sl_status_t dotdot_set_level_current_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_frequency, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_current_frequency_undefine_reported( +@@ -12438,7 +12438,7 @@ bool dotdot_is_supported_level_min_frequency( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_min_frequency( ++uint16_t dotdot_get_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12449,7 +12449,7 @@ int16_t dotdot_get_level_min_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MIN_FREQUENCY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12461,7 +12461,7 @@ sl_status_t dotdot_set_level_min_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_frequency ++ uint16_t new_min_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12474,7 +12474,7 @@ sl_status_t dotdot_set_level_min_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_frequency, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_min_frequency_undefine_reported( +@@ -12549,7 +12549,7 @@ bool dotdot_is_supported_level_max_frequency( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_max_frequency( ++uint16_t dotdot_get_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12560,7 +12560,7 @@ int16_t dotdot_get_level_max_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_MAX_FREQUENCY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12572,7 +12572,7 @@ sl_status_t dotdot_set_level_max_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_frequency ++ uint16_t new_max_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12585,7 +12585,7 @@ sl_status_t dotdot_set_level_max_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_frequency, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_max_frequency_undefine_reported( +@@ -12771,7 +12771,7 @@ bool dotdot_is_supported_level_on_off_transition_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_on_off_transition_time( ++uint16_t dotdot_get_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12782,7 +12782,7 @@ int16_t dotdot_get_level_on_off_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_OFF_TRANSITION_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12794,7 +12794,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_off_transition_time ++ uint16_t new_on_off_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12807,7 +12807,7 @@ sl_status_t dotdot_set_level_on_off_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_off_transition_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_on_off_transition_time_undefine_reported( +@@ -12882,7 +12882,7 @@ bool dotdot_is_supported_level_on_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_level_on_level( ++uint8_t dotdot_get_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -12893,7 +12893,7 @@ int8_t dotdot_get_level_on_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -12905,7 +12905,7 @@ sl_status_t dotdot_set_level_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_on_level ++ uint8_t new_on_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -12918,7 +12918,7 @@ sl_status_t dotdot_set_level_on_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_level_on_level_undefine_reported( +@@ -12993,7 +12993,7 @@ bool dotdot_is_supported_level_on_transition_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_on_transition_time( ++uint16_t dotdot_get_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13004,7 +13004,7 @@ int16_t dotdot_get_level_on_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_ON_TRANSITION_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13016,7 +13016,7 @@ sl_status_t dotdot_set_level_on_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_on_transition_time ++ uint16_t new_on_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13029,7 +13029,7 @@ sl_status_t dotdot_set_level_on_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_on_transition_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_on_transition_time_undefine_reported( +@@ -13104,7 +13104,7 @@ bool dotdot_is_supported_level_off_transition_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_off_transition_time( ++uint16_t dotdot_get_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13115,7 +13115,7 @@ int16_t dotdot_get_level_off_transition_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_OFF_TRANSITION_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13127,7 +13127,7 @@ sl_status_t dotdot_set_level_off_transition_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_off_transition_time ++ uint16_t new_off_transition_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13140,7 +13140,7 @@ sl_status_t dotdot_set_level_off_transition_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_off_transition_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_off_transition_time_undefine_reported( +@@ -13215,7 +13215,7 @@ bool dotdot_is_supported_level_default_move_rate( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_level_default_move_rate( ++uint16_t dotdot_get_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13226,7 +13226,7 @@ int16_t dotdot_get_level_default_move_rate( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_DEFAULT_MOVE_RATE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13238,7 +13238,7 @@ sl_status_t dotdot_set_level_default_move_rate( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_default_move_rate ++ uint16_t new_default_move_rate + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13251,7 +13251,7 @@ sl_status_t dotdot_set_level_default_move_rate( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_default_move_rate, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_level_default_move_rate_undefine_reported( +@@ -13326,7 +13326,7 @@ bool dotdot_is_supported_level_start_up_current_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_level_start_up_current_level( ++uint8_t dotdot_get_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13337,7 +13337,7 @@ int8_t dotdot_get_level_start_up_current_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_LEVEL_START_UP_CURRENT_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13349,7 +13349,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_start_up_current_level ++ uint8_t new_start_up_current_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13362,7 +13362,7 @@ sl_status_t dotdot_set_level_start_up_current_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_start_up_current_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_level_start_up_current_level_undefine_reported( +@@ -13519,7 +13519,7 @@ bool dotdot_is_supported_alarms_alarm_count( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_alarms_alarm_count( ++uint16_t dotdot_get_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13530,7 +13530,7 @@ int16_t dotdot_get_alarms_alarm_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ALARMS_ALARM_COUNT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13542,7 +13542,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_alarm_count ++ uint16_t new_alarm_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13555,7 +13555,7 @@ sl_status_t dotdot_set_alarms_alarm_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_alarm_count, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_alarms_alarm_count_undefine_reported( +@@ -13652,7 +13652,7 @@ bool dotdot_is_supported_time_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_time_time( ++uint32_t dotdot_get_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13663,7 +13663,7 @@ uint8_t dotdot_get_time_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -13675,7 +13675,7 @@ sl_status_t dotdot_set_time_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_time ++ uint32_t new_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -13688,7 +13688,7 @@ sl_status_t dotdot_set_time_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_time_undefine_reported( +@@ -13985,7 +13985,7 @@ bool dotdot_is_supported_time_dst_start( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_time_dst_start( ++uint32_t dotdot_get_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -13996,7 +13996,7 @@ int32_t dotdot_get_time_dst_start( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_DST_START); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14008,7 +14008,7 @@ sl_status_t dotdot_set_time_dst_start( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_dst_start ++ uint32_t new_dst_start + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14021,7 +14021,7 @@ sl_status_t dotdot_set_time_dst_start( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dst_start, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_dst_start_undefine_reported( +@@ -14096,7 +14096,7 @@ bool dotdot_is_supported_time_dst_end( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_time_dst_end( ++uint32_t dotdot_get_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14107,7 +14107,7 @@ int32_t dotdot_get_time_dst_end( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_DST_END); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14119,7 +14119,7 @@ sl_status_t dotdot_set_time_dst_end( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_dst_end ++ uint32_t new_dst_end + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14132,7 +14132,7 @@ sl_status_t dotdot_set_time_dst_end( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dst_end, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_dst_end_undefine_reported( +@@ -14318,7 +14318,7 @@ bool dotdot_is_supported_time_standard_time( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_time_standard_time( ++uint32_t dotdot_get_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14329,7 +14329,7 @@ int32_t dotdot_get_time_standard_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_STANDARD_TIME); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14341,7 +14341,7 @@ sl_status_t dotdot_set_time_standard_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_standard_time ++ uint32_t new_standard_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14354,7 +14354,7 @@ sl_status_t dotdot_set_time_standard_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_standard_time, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_standard_time_undefine_reported( +@@ -14429,7 +14429,7 @@ bool dotdot_is_supported_time_local_time( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_time_local_time( ++uint32_t dotdot_get_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14440,7 +14440,7 @@ int32_t dotdot_get_time_local_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_LOCAL_TIME); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14452,7 +14452,7 @@ sl_status_t dotdot_set_time_local_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_local_time ++ uint32_t new_local_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14465,7 +14465,7 @@ sl_status_t dotdot_set_time_local_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_local_time, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_local_time_undefine_reported( +@@ -14540,7 +14540,7 @@ bool dotdot_is_supported_time_last_set_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_time_last_set_time( ++uint32_t dotdot_get_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14551,7 +14551,7 @@ uint8_t dotdot_get_time_last_set_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_LAST_SET_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14563,7 +14563,7 @@ sl_status_t dotdot_set_time_last_set_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_last_set_time ++ uint32_t new_last_set_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14576,7 +14576,7 @@ sl_status_t dotdot_set_time_last_set_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_last_set_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_last_set_time_undefine_reported( +@@ -14651,7 +14651,7 @@ bool dotdot_is_supported_time_valid_until_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_time_valid_until_time( ++uint32_t dotdot_get_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14662,7 +14662,7 @@ uint8_t dotdot_get_time_valid_until_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TIME_VALID_UNTIL_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14674,7 +14674,7 @@ sl_status_t dotdot_set_time_valid_until_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_valid_until_time ++ uint32_t new_valid_until_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14687,7 +14687,7 @@ sl_status_t dotdot_set_time_valid_until_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_valid_until_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_time_valid_until_time_undefine_reported( +@@ -14832,7 +14832,7 @@ bool dotdot_is_supported_poll_control_check_in_interval( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_poll_control_check_in_interval( ++uint32_t dotdot_get_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14843,7 +14843,7 @@ int32_t dotdot_get_poll_control_check_in_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14855,7 +14855,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_check_in_interval ++ uint32_t new_check_in_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14868,7 +14868,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_check_in_interval, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_poll_control_check_in_interval_undefine_reported( +@@ -14943,7 +14943,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_poll_control_long_poll_interval( ++uint32_t dotdot_get_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -14954,7 +14954,7 @@ int32_t dotdot_get_poll_control_long_poll_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -14966,7 +14966,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_long_poll_interval ++ uint32_t new_long_poll_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -14979,7 +14979,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_long_poll_interval, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_poll_control_long_poll_interval_undefine_reported( +@@ -15054,7 +15054,7 @@ bool dotdot_is_supported_poll_control_short_poll_interval( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_poll_control_short_poll_interval( ++uint16_t dotdot_get_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15065,7 +15065,7 @@ int16_t dotdot_get_poll_control_short_poll_interval( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_SHORT_POLL_INTERVAL); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15077,7 +15077,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_short_poll_interval ++ uint16_t new_short_poll_interval + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15090,7 +15090,7 @@ sl_status_t dotdot_set_poll_control_short_poll_interval( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_short_poll_interval, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_poll_control_short_poll_interval_undefine_reported( +@@ -15165,7 +15165,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_poll_control_fast_poll_timeout( ++uint16_t dotdot_get_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15176,7 +15176,7 @@ int16_t dotdot_get_poll_control_fast_poll_timeout( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15188,7 +15188,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_fast_poll_timeout ++ uint16_t new_fast_poll_timeout + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15201,7 +15201,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_fast_poll_timeout, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_poll_control_fast_poll_timeout_undefine_reported( +@@ -15276,7 +15276,7 @@ bool dotdot_is_supported_poll_control_check_in_interval_min( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_poll_control_check_in_interval_min( ++uint32_t dotdot_get_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15287,7 +15287,7 @@ int32_t dotdot_get_poll_control_check_in_interval_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_CHECK_IN_INTERVAL_MIN); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15299,7 +15299,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_check_in_interval_min ++ uint32_t new_check_in_interval_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15312,7 +15312,7 @@ sl_status_t dotdot_set_poll_control_check_in_interval_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_check_in_interval_min, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_poll_control_check_in_interval_min_undefine_reported( +@@ -15387,7 +15387,7 @@ bool dotdot_is_supported_poll_control_long_poll_interval_min( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_poll_control_long_poll_interval_min( ++uint32_t dotdot_get_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15398,7 +15398,7 @@ int32_t dotdot_get_poll_control_long_poll_interval_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_LONG_POLL_INTERVAL_MIN); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15410,7 +15410,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_long_poll_interval_min ++ uint32_t new_long_poll_interval_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15423,7 +15423,7 @@ sl_status_t dotdot_set_poll_control_long_poll_interval_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_long_poll_interval_min, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_poll_control_long_poll_interval_min_undefine_reported( +@@ -15498,7 +15498,7 @@ bool dotdot_is_supported_poll_control_fast_poll_timeout_max( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_poll_control_fast_poll_timeout_max( ++uint16_t dotdot_get_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15509,7 +15509,7 @@ int16_t dotdot_get_poll_control_fast_poll_timeout_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_POLL_CONTROL_FAST_POLL_TIMEOUT_MAX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15521,7 +15521,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_fast_poll_timeout_max ++ uint16_t new_fast_poll_timeout_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15534,7 +15534,7 @@ sl_status_t dotdot_set_poll_control_fast_poll_timeout_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_fast_poll_timeout_max, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_poll_control_fast_poll_timeout_max_undefine_reported( +@@ -15655,7 +15655,7 @@ bool dotdot_is_supported_shade_configuration_physical_closed_limit( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_shade_configuration_physical_closed_limit( ++uint16_t dotdot_get_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15666,7 +15666,7 @@ int16_t dotdot_get_shade_configuration_physical_closed_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_PHYSICAL_CLOSED_LIMIT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15678,7 +15678,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit ++ uint16_t new_physical_closed_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15691,7 +15691,7 @@ sl_status_t dotdot_set_shade_configuration_physical_closed_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_shade_configuration_physical_closed_limit_undefine_reported( +@@ -15766,7 +15766,7 @@ bool dotdot_is_supported_shade_configuration_motor_step_size( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_shade_configuration_motor_step_size( ++uint8_t dotdot_get_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15777,7 +15777,7 @@ int8_t dotdot_get_shade_configuration_motor_step_size( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_MOTOR_STEP_SIZE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -15789,7 +15789,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_motor_step_size ++ uint8_t new_motor_step_size + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -15802,7 +15802,7 @@ sl_status_t dotdot_set_shade_configuration_motor_step_size( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_motor_step_size, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_shade_configuration_motor_step_size_undefine_reported( +@@ -15988,7 +15988,7 @@ bool dotdot_is_supported_shade_configuration_closed_limit( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_shade_configuration_closed_limit( ++uint16_t dotdot_get_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -15999,7 +15999,7 @@ int16_t dotdot_get_shade_configuration_closed_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SHADE_CONFIGURATION_CLOSED_LIMIT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16011,7 +16011,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_closed_limit ++ uint16_t new_closed_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16024,7 +16024,7 @@ sl_status_t dotdot_set_shade_configuration_closed_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_closed_limit, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_shade_configuration_closed_limit_undefine_reported( +@@ -16697,7 +16697,7 @@ bool dotdot_is_supported_door_lock_door_open_events( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_door_lock_door_open_events( ++uint32_t dotdot_get_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16708,7 +16708,7 @@ int32_t dotdot_get_door_lock_door_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_OPEN_EVENTS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16720,7 +16720,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_door_open_events ++ uint32_t new_door_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16733,7 +16733,7 @@ sl_status_t dotdot_set_door_lock_door_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_door_open_events, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_door_lock_door_open_events_undefine_reported( +@@ -16808,7 +16808,7 @@ bool dotdot_is_supported_door_lock_door_closed_events( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_door_lock_door_closed_events( ++uint32_t dotdot_get_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16819,7 +16819,7 @@ int32_t dotdot_get_door_lock_door_closed_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_DOOR_CLOSED_EVENTS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16831,7 +16831,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_door_closed_events ++ uint32_t new_door_closed_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16844,7 +16844,7 @@ sl_status_t dotdot_set_door_lock_door_closed_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_door_closed_events, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_door_lock_door_closed_events_undefine_reported( +@@ -16919,7 +16919,7 @@ bool dotdot_is_supported_door_lock_open_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_open_period( ++uint16_t dotdot_get_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -16930,7 +16930,7 @@ int16_t dotdot_get_door_lock_open_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_OPEN_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -16942,7 +16942,7 @@ sl_status_t dotdot_set_door_lock_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_period ++ uint16_t new_open_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -16955,7 +16955,7 @@ sl_status_t dotdot_set_door_lock_open_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_open_period_undefine_reported( +@@ -17030,7 +17030,7 @@ bool dotdot_is_supported_door_lock_number_of_log_records_supported( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_number_of_log_records_supported( ++uint16_t dotdot_get_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17041,7 +17041,7 @@ int16_t dotdot_get_door_lock_number_of_log_records_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_LOG_RECORDS_SUPPORTED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17053,7 +17053,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_log_records_supported ++ uint16_t new_number_of_log_records_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17066,7 +17066,7 @@ sl_status_t dotdot_set_door_lock_number_of_log_records_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_log_records_supported, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_number_of_log_records_supported_undefine_reported( +@@ -17141,7 +17141,7 @@ bool dotdot_is_supported_door_lock_number_of_total_users_supported( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_number_of_total_users_supported( ++uint16_t dotdot_get_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17152,7 +17152,7 @@ int16_t dotdot_get_door_lock_number_of_total_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_TOTAL_USERS_SUPPORTED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17164,7 +17164,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_total_users_supported ++ uint16_t new_number_of_total_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17177,7 +17177,7 @@ sl_status_t dotdot_set_door_lock_number_of_total_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_total_users_supported, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_number_of_total_users_supported_undefine_reported( +@@ -17252,7 +17252,7 @@ bool dotdot_is_supported_door_lock_number_of_pin_users_supported( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_number_of_pin_users_supported( ++uint16_t dotdot_get_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17263,7 +17263,7 @@ int16_t dotdot_get_door_lock_number_of_pin_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_PIN_USERS_SUPPORTED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17275,7 +17275,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_pin_users_supported ++ uint16_t new_number_of_pin_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17288,7 +17288,7 @@ sl_status_t dotdot_set_door_lock_number_of_pin_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_pin_users_supported, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_number_of_pin_users_supported_undefine_reported( +@@ -17363,7 +17363,7 @@ bool dotdot_is_supported_door_lock_number_of_rfid_users_supported( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_number_of_rfid_users_supported( ++uint16_t dotdot_get_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17374,7 +17374,7 @@ int16_t dotdot_get_door_lock_number_of_rfid_users_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_RFID_USERS_SUPPORTED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17386,7 +17386,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_rfid_users_supported ++ uint16_t new_number_of_rfid_users_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17399,7 +17399,7 @@ sl_status_t dotdot_set_door_lock_number_of_rfid_users_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_rfid_users_supported, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_number_of_rfid_users_supported_undefine_reported( +@@ -17474,7 +17474,7 @@ bool dotdot_is_supported_door_lock_number_of_week_day_schedules_supported_per_us + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17485,7 +17485,7 @@ int8_t dotdot_get_door_lock_number_of_week_day_schedules_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_WEEK_DAY_SCHEDULES_SUPPORTED_PER_USER); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17497,7 +17497,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_week_day_schedules_supported_per_user ++ uint8_t new_number_of_week_day_schedules_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17510,7 +17510,7 @@ sl_status_t dotdot_set_door_lock_number_of_week_day_schedules_supported_per_user + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_week_day_schedules_supported_per_user, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_number_of_week_day_schedules_supported_per_user_undefine_reported( +@@ -17585,7 +17585,7 @@ bool dotdot_is_supported_door_lock_number_of_year_day_schedules_supported_per_us + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17596,7 +17596,7 @@ int8_t dotdot_get_door_lock_number_of_year_day_schedules_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_YEAR_DAY_SCHEDULES_SUPPORTED_PER_USER); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17608,7 +17608,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_year_day_schedules_supported_per_user ++ uint8_t new_number_of_year_day_schedules_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17621,7 +17621,7 @@ sl_status_t dotdot_set_door_lock_number_of_year_day_schedules_supported_per_user + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_year_day_schedules_supported_per_user, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_number_of_year_day_schedules_supported_per_user_undefine_reported( +@@ -17696,7 +17696,7 @@ bool dotdot_is_supported_door_lock_number_of_holiday_schedules_supported( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( ++uint8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17707,7 +17707,7 @@ int8_t dotdot_get_door_lock_number_of_holiday_schedules_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_HOLIDAY_SCHEDULES_SUPPORTED); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17719,7 +17719,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_holiday_schedules_supported ++ uint8_t new_number_of_holiday_schedules_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17732,7 +17732,7 @@ sl_status_t dotdot_set_door_lock_number_of_holiday_schedules_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_holiday_schedules_supported, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_number_of_holiday_schedules_supported_undefine_reported( +@@ -17807,7 +17807,7 @@ bool dotdot_is_supported_door_lock_max_pin_code_length( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_max_pin_code_length( ++uint8_t dotdot_get_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17818,7 +17818,7 @@ int8_t dotdot_get_door_lock_max_pin_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_PIN_CODE_LENGTH); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17830,7 +17830,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_pin_code_length ++ uint8_t new_max_pin_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17843,7 +17843,7 @@ sl_status_t dotdot_set_door_lock_max_pin_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_pin_code_length, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_max_pin_code_length_undefine_reported( +@@ -17918,7 +17918,7 @@ bool dotdot_is_supported_door_lock_min_pin_code_length( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_min_pin_code_length( ++uint8_t dotdot_get_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -17929,7 +17929,7 @@ int8_t dotdot_get_door_lock_min_pin_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_PIN_CODE_LENGTH); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -17941,7 +17941,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_pin_code_length ++ uint8_t new_min_pin_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -17954,7 +17954,7 @@ sl_status_t dotdot_set_door_lock_min_pin_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_pin_code_length, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_min_pin_code_length_undefine_reported( +@@ -18029,7 +18029,7 @@ bool dotdot_is_supported_door_lock_max_rfid_code_length( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_max_rfid_code_length( ++uint8_t dotdot_get_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18040,7 +18040,7 @@ int8_t dotdot_get_door_lock_max_rfid_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MAX_RFID_CODE_LENGTH); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18052,7 +18052,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_rfid_code_length ++ uint8_t new_max_rfid_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18065,7 +18065,7 @@ sl_status_t dotdot_set_door_lock_max_rfid_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_rfid_code_length, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_max_rfid_code_length_undefine_reported( +@@ -18140,7 +18140,7 @@ bool dotdot_is_supported_door_lock_min_rfid_code_length( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_min_rfid_code_length( ++uint8_t dotdot_get_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18151,7 +18151,7 @@ int8_t dotdot_get_door_lock_min_rfid_code_length( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_MIN_RFID_CODE_LENGTH); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18163,7 +18163,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_rfid_code_length ++ uint8_t new_min_rfid_code_length + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18176,7 +18176,7 @@ sl_status_t dotdot_set_door_lock_min_rfid_code_length( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_rfid_code_length, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_min_rfid_code_length_undefine_reported( +@@ -18362,7 +18362,7 @@ bool dotdot_is_supported_door_lock_number_of_credentials_supported_per_user( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( ++uint8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18373,7 +18373,7 @@ int8_t dotdot_get_door_lock_number_of_credentials_supported_per_user( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_NUMBER_OF_CREDENTIALS_SUPPORTED_PER_USER); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18385,7 +18385,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_credentials_supported_per_user ++ uint8_t new_number_of_credentials_supported_per_user + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18398,7 +18398,7 @@ sl_status_t dotdot_set_door_lock_number_of_credentials_supported_per_user( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_credentials_supported_per_user, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_number_of_credentials_supported_per_user_undefine_reported( +@@ -18696,7 +18696,7 @@ bool dotdot_is_supported_door_lock_led_settings( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_led_settings( ++uint8_t dotdot_get_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18707,7 +18707,7 @@ int8_t dotdot_get_door_lock_led_settings( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_LED_SETTINGS); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18719,7 +18719,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_led_settings ++ uint8_t new_led_settings + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18732,7 +18732,7 @@ sl_status_t dotdot_set_door_lock_led_settings( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_led_settings, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_led_settings_undefine_reported( +@@ -18807,7 +18807,7 @@ bool dotdot_is_supported_door_lock_auto_relock_time( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_door_lock_auto_relock_time( ++uint32_t dotdot_get_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18818,7 +18818,7 @@ int32_t dotdot_get_door_lock_auto_relock_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_AUTO_RELOCK_TIME); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18830,7 +18830,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_auto_relock_time ++ uint32_t new_auto_relock_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18843,7 +18843,7 @@ sl_status_t dotdot_set_door_lock_auto_relock_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_auto_relock_time, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_door_lock_auto_relock_time_undefine_reported( +@@ -18918,7 +18918,7 @@ bool dotdot_is_supported_door_lock_sound_volume( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_sound_volume( ++uint8_t dotdot_get_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -18929,7 +18929,7 @@ int8_t dotdot_get_door_lock_sound_volume( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_SOUND_VOLUME); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -18941,7 +18941,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_sound_volume ++ uint8_t new_sound_volume + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -18954,7 +18954,7 @@ sl_status_t dotdot_set_door_lock_sound_volume( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_sound_volume, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_sound_volume_undefine_reported( +@@ -19917,7 +19917,7 @@ bool dotdot_is_supported_door_lock_wrong_code_entry_limit( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_wrong_code_entry_limit( ++uint8_t dotdot_get_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -19928,7 +19928,7 @@ int8_t dotdot_get_door_lock_wrong_code_entry_limit( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_WRONG_CODE_ENTRY_LIMIT); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -19940,7 +19940,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_wrong_code_entry_limit ++ uint8_t new_wrong_code_entry_limit + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -19953,7 +19953,7 @@ sl_status_t dotdot_set_door_lock_wrong_code_entry_limit( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_wrong_code_entry_limit, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_wrong_code_entry_limit_undefine_reported( +@@ -20028,7 +20028,7 @@ bool dotdot_is_supported_door_lock_user_code_temporary_disable_time( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_door_lock_user_code_temporary_disable_time( ++uint8_t dotdot_get_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -20039,7 +20039,7 @@ int8_t dotdot_get_door_lock_user_code_temporary_disable_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_USER_CODE_TEMPORARY_DISABLE_TIME); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -20051,7 +20051,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_user_code_temporary_disable_time ++ uint8_t new_user_code_temporary_disable_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -20064,7 +20064,7 @@ sl_status_t dotdot_set_door_lock_user_code_temporary_disable_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_user_code_temporary_disable_time, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_door_lock_user_code_temporary_disable_time_undefine_reported( +@@ -20472,7 +20472,7 @@ bool dotdot_is_supported_door_lock_expiring_user_timeout( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_door_lock_expiring_user_timeout( ++uint16_t dotdot_get_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -20483,7 +20483,7 @@ int16_t dotdot_get_door_lock_expiring_user_timeout( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DOOR_LOCK_EXPIRING_USER_TIMEOUT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -20495,7 +20495,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_expiring_user_timeout ++ uint16_t new_expiring_user_timeout + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -20508,7 +20508,7 @@ sl_status_t dotdot_set_door_lock_expiring_user_timeout( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_expiring_user_timeout, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_door_lock_expiring_user_timeout_undefine_reported( +@@ -21937,7 +21937,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_physical_closed_limit_lift( ++uint16_t dotdot_get_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -21948,7 +21948,7 @@ int16_t dotdot_get_window_covering_physical_closed_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -21960,7 +21960,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit_lift ++ uint16_t new_physical_closed_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -21973,7 +21973,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_physical_closed_limit_lift_undefine_reported( +@@ -22048,7 +22048,7 @@ bool dotdot_is_supported_window_covering_physical_closed_limit_tilt( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_physical_closed_limit_tilt( ++uint16_t dotdot_get_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22059,7 +22059,7 @@ int16_t dotdot_get_window_covering_physical_closed_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_PHYSICAL_CLOSED_LIMIT_TILT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22071,7 +22071,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_closed_limit_tilt ++ uint16_t new_physical_closed_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22084,7 +22084,7 @@ sl_status_t dotdot_set_window_covering_physical_closed_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_closed_limit_tilt, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_physical_closed_limit_tilt_undefine_reported( +@@ -22159,7 +22159,7 @@ bool dotdot_is_supported_window_covering_current_position_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_current_position_lift( ++uint16_t dotdot_get_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22170,7 +22170,7 @@ int16_t dotdot_get_window_covering_current_position_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22182,7 +22182,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_position_lift ++ uint16_t new_current_position_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22195,7 +22195,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_current_position_lift_undefine_reported( +@@ -22270,7 +22270,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_current_position_tilt( ++uint16_t dotdot_get_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22281,7 +22281,7 @@ int16_t dotdot_get_window_covering_current_position_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22293,7 +22293,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_current_position_tilt ++ uint16_t new_current_position_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22306,7 +22306,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_tilt, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_current_position_tilt_undefine_reported( +@@ -22381,7 +22381,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_number_of_actuations_lift( ++uint16_t dotdot_get_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22392,7 +22392,7 @@ int16_t dotdot_get_window_covering_number_of_actuations_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22404,7 +22404,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_actuations_lift ++ uint16_t new_number_of_actuations_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22417,7 +22417,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_actuations_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_number_of_actuations_lift_undefine_reported( +@@ -22492,7 +22492,7 @@ bool dotdot_is_supported_window_covering_number_of_actuations_tilt( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_number_of_actuations_tilt( ++uint16_t dotdot_get_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22503,7 +22503,7 @@ int16_t dotdot_get_window_covering_number_of_actuations_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_NUMBER_OF_ACTUATIONS_TILT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22515,7 +22515,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_actuations_tilt ++ uint16_t new_number_of_actuations_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22528,7 +22528,7 @@ sl_status_t dotdot_set_window_covering_number_of_actuations_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_actuations_tilt, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_number_of_actuations_tilt_undefine_reported( +@@ -22714,7 +22714,7 @@ bool dotdot_is_supported_window_covering_current_position_lift_percentage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_window_covering_current_position_lift_percentage( ++uint8_t dotdot_get_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22725,7 +22725,7 @@ int8_t dotdot_get_window_covering_current_position_lift_percentage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22737,7 +22737,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_position_lift_percentage ++ uint8_t new_current_position_lift_percentage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22750,7 +22750,7 @@ sl_status_t dotdot_set_window_covering_current_position_lift_percentage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_lift_percentage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_window_covering_current_position_lift_percentage_undefine_reported( +@@ -22825,7 +22825,7 @@ bool dotdot_is_supported_window_covering_current_position_tilt_percentage( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_window_covering_current_position_tilt_percentage( ++uint8_t dotdot_get_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22836,7 +22836,7 @@ int8_t dotdot_get_window_covering_current_position_tilt_percentage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22848,7 +22848,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_position_tilt_percentage ++ uint8_t new_current_position_tilt_percentage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22861,7 +22861,7 @@ sl_status_t dotdot_set_window_covering_current_position_tilt_percentage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_position_tilt_percentage, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_window_covering_current_position_tilt_percentage_undefine_reported( +@@ -22936,7 +22936,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_installed_open_limit_lift( ++uint16_t dotdot_get_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -22947,7 +22947,7 @@ int16_t dotdot_get_window_covering_installed_open_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -22959,7 +22959,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_open_limit_lift ++ uint16_t new_installed_open_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -22972,7 +22972,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_open_limit_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_installed_open_limit_lift_undefine_reported( +@@ -23047,7 +23047,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_installed_closed_limit_lift( ++uint16_t dotdot_get_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23058,7 +23058,7 @@ int16_t dotdot_get_window_covering_installed_closed_limit_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23070,7 +23070,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_closed_limit_lift ++ uint16_t new_installed_closed_limit_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23083,7 +23083,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_closed_limit_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_installed_closed_limit_lift_undefine_reported( +@@ -23158,7 +23158,7 @@ bool dotdot_is_supported_window_covering_installed_open_limit_tilt( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_installed_open_limit_tilt( ++uint16_t dotdot_get_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23169,7 +23169,7 @@ int16_t dotdot_get_window_covering_installed_open_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23181,7 +23181,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_open_limit_tilt ++ uint16_t new_installed_open_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23194,7 +23194,7 @@ sl_status_t dotdot_set_window_covering_installed_open_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_open_limit_tilt, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_installed_open_limit_tilt_undefine_reported( +@@ -23269,7 +23269,7 @@ bool dotdot_is_supported_window_covering_installed_closed_limit_tilt( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_installed_closed_limit_tilt( ++uint16_t dotdot_get_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23280,7 +23280,7 @@ int16_t dotdot_get_window_covering_installed_closed_limit_tilt( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23292,7 +23292,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_installed_closed_limit_tilt ++ uint16_t new_installed_closed_limit_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23305,7 +23305,7 @@ sl_status_t dotdot_set_window_covering_installed_closed_limit_tilt( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_installed_closed_limit_tilt, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_installed_closed_limit_tilt_undefine_reported( +@@ -23380,7 +23380,7 @@ bool dotdot_is_supported_window_covering_velocity_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_velocity_lift( ++uint16_t dotdot_get_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23391,7 +23391,7 @@ int16_t dotdot_get_window_covering_velocity_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_VELOCITY_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23403,7 +23403,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_velocity_lift ++ uint16_t new_velocity_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23416,7 +23416,7 @@ sl_status_t dotdot_set_window_covering_velocity_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_velocity_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_velocity_lift_undefine_reported( +@@ -23491,7 +23491,7 @@ bool dotdot_is_supported_window_covering_acceleration_time_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_acceleration_time_lift( ++uint16_t dotdot_get_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23502,7 +23502,7 @@ int16_t dotdot_get_window_covering_acceleration_time_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_ACCELERATION_TIME_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23514,7 +23514,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_acceleration_time_lift ++ uint16_t new_acceleration_time_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23527,7 +23527,7 @@ sl_status_t dotdot_set_window_covering_acceleration_time_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_acceleration_time_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_acceleration_time_lift_undefine_reported( +@@ -23602,7 +23602,7 @@ bool dotdot_is_supported_window_covering_deceleration_time_lift( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_window_covering_deceleration_time_lift( ++uint16_t dotdot_get_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23613,7 +23613,7 @@ int16_t dotdot_get_window_covering_deceleration_time_lift( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WINDOW_COVERING_DECELERATION_TIME_LIFT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -23625,7 +23625,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_deceleration_time_lift ++ uint16_t new_deceleration_time_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23638,7 +23638,7 @@ sl_status_t dotdot_set_window_covering_deceleration_time_lift( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_deceleration_time_lift, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_window_covering_deceleration_time_lift_undefine_reported( +@@ -23824,7 +23824,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_lift( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_window_covering_intermediate_setpoints_lift( ++const char* dotdot_get_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23847,7 +23847,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_lift( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intermediate_setpoints_lift ++ const char* new_intermediate_setpoints_lift + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -23936,7 +23936,7 @@ bool dotdot_is_supported_window_covering_intermediate_setpoints_tilt( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_window_covering_intermediate_setpoints_tilt( ++const char* dotdot_get_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -23959,7 +23959,7 @@ sl_status_t dotdot_set_window_covering_intermediate_setpoints_tilt( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_intermediate_setpoints_tilt ++ const char* new_intermediate_setpoints_tilt + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24472,7 +24472,7 @@ bool dotdot_is_supported_barrier_control_open_events( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_open_events( ++uint16_t dotdot_get_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24483,7 +24483,7 @@ int16_t dotdot_get_barrier_control_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_EVENTS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24495,7 +24495,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_events ++ uint16_t new_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24508,7 +24508,7 @@ sl_status_t dotdot_set_barrier_control_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_events, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_open_events_undefine_reported( +@@ -24583,7 +24583,7 @@ bool dotdot_is_supported_barrier_control_close_events( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_close_events( ++uint16_t dotdot_get_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24594,7 +24594,7 @@ int16_t dotdot_get_barrier_control_close_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_EVENTS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24606,7 +24606,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_close_events ++ uint16_t new_close_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24619,7 +24619,7 @@ sl_status_t dotdot_set_barrier_control_close_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_close_events, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_close_events_undefine_reported( +@@ -24694,7 +24694,7 @@ bool dotdot_is_supported_barrier_control_command_open_events( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_command_open_events( ++uint16_t dotdot_get_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24705,7 +24705,7 @@ int16_t dotdot_get_barrier_control_command_open_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_OPEN_EVENTS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24717,7 +24717,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_command_open_events ++ uint16_t new_command_open_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24730,7 +24730,7 @@ sl_status_t dotdot_set_barrier_control_command_open_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_command_open_events, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_command_open_events_undefine_reported( +@@ -24805,7 +24805,7 @@ bool dotdot_is_supported_barrier_control_command_close_events( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_command_close_events( ++uint16_t dotdot_get_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24816,7 +24816,7 @@ int16_t dotdot_get_barrier_control_command_close_events( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_COMMAND_CLOSE_EVENTS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24828,7 +24828,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_command_close_events ++ uint16_t new_command_close_events + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24841,7 +24841,7 @@ sl_status_t dotdot_set_barrier_control_command_close_events( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_command_close_events, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_command_close_events_undefine_reported( +@@ -24916,7 +24916,7 @@ bool dotdot_is_supported_barrier_control_open_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_open_period( ++uint16_t dotdot_get_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -24927,7 +24927,7 @@ int16_t dotdot_get_barrier_control_open_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_OPEN_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -24939,7 +24939,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_open_period ++ uint16_t new_open_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -24952,7 +24952,7 @@ sl_status_t dotdot_set_barrier_control_open_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_open_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_open_period_undefine_reported( +@@ -25027,7 +25027,7 @@ bool dotdot_is_supported_barrier_control_close_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_barrier_control_close_period( ++uint16_t dotdot_get_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25038,7 +25038,7 @@ int16_t dotdot_get_barrier_control_close_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_CLOSE_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25050,7 +25050,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_close_period ++ uint16_t new_close_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25063,7 +25063,7 @@ sl_status_t dotdot_set_barrier_control_close_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_close_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_barrier_control_close_period_undefine_reported( +@@ -25138,7 +25138,7 @@ bool dotdot_is_supported_barrier_control_barrier_position( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_barrier_control_barrier_position( ++uint8_t dotdot_get_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25149,7 +25149,7 @@ int8_t dotdot_get_barrier_control_barrier_position( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BARRIER_CONTROL_BARRIER_POSITION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25161,7 +25161,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_barrier_position ++ uint8_t new_barrier_position + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25174,7 +25174,7 @@ sl_status_t dotdot_set_barrier_control_barrier_position( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_barrier_position, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_barrier_control_barrier_position_undefine_reported( +@@ -25427,7 +25427,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_speed( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_max_speed( ++uint16_t dotdot_get_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25438,7 +25438,7 @@ int16_t dotdot_get_pump_configuration_and_control_max_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_SPEED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25450,7 +25450,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_speed ++ uint16_t new_max_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25463,7 +25463,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_speed, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_speed_undefine_reported( +@@ -25538,7 +25538,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_flow( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_max_flow( ++uint16_t dotdot_get_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -25549,7 +25549,7 @@ int16_t dotdot_get_pump_configuration_and_control_max_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_FLOW); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -25561,7 +25561,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_flow ++ uint16_t new_max_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -25574,7 +25574,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_flow, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_flow_undefine_reported( +@@ -26093,7 +26093,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_speed( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_min_const_speed( ++uint16_t dotdot_get_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26104,7 +26104,7 @@ int16_t dotdot_get_pump_configuration_and_control_min_const_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_SPEED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26116,7 +26116,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_const_speed ++ uint16_t new_min_const_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26129,7 +26129,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_const_speed, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_min_const_speed_undefine_reported( +@@ -26204,7 +26204,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_speed( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_max_const_speed( ++uint16_t dotdot_get_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26215,7 +26215,7 @@ int16_t dotdot_get_pump_configuration_and_control_max_const_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_SPEED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26227,7 +26227,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_const_speed ++ uint16_t new_max_const_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26240,7 +26240,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_const_speed, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_const_speed_undefine_reported( +@@ -26315,7 +26315,7 @@ bool dotdot_is_supported_pump_configuration_and_control_min_const_flow( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_min_const_flow( ++uint16_t dotdot_get_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26326,7 +26326,7 @@ int16_t dotdot_get_pump_configuration_and_control_min_const_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MIN_CONST_FLOW); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26338,7 +26338,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_const_flow ++ uint16_t new_min_const_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26351,7 +26351,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_min_const_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_const_flow, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_min_const_flow_undefine_reported( +@@ -26426,7 +26426,7 @@ bool dotdot_is_supported_pump_configuration_and_control_max_const_flow( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_max_const_flow( ++uint16_t dotdot_get_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -26437,7 +26437,7 @@ int16_t dotdot_get_pump_configuration_and_control_max_const_flow( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_MAX_CONST_FLOW); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -26449,7 +26449,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_const_flow ++ uint16_t new_max_const_flow + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -26462,7 +26462,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_max_const_flow( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_const_flow, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_max_const_flow_undefine_reported( +@@ -27203,7 +27203,7 @@ bool dotdot_is_supported_pump_configuration_and_control_speed( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pump_configuration_and_control_speed( ++uint16_t dotdot_get_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27214,7 +27214,7 @@ int16_t dotdot_get_pump_configuration_and_control_speed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_SPEED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27226,7 +27226,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_speed ++ uint16_t new_speed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27239,7 +27239,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_speed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_speed, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_speed_undefine_reported( +@@ -27314,7 +27314,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_running_hours( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( ++uint32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27325,7 +27325,7 @@ int32_t dotdot_get_pump_configuration_and_control_lifetime_running_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_RUNNING_HOURS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27337,7 +27337,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lifetime_running_hours ++ uint32_t new_lifetime_running_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27350,7 +27350,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_running_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lifetime_running_hours, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_lifetime_running_hours_undefine_reported( +@@ -27425,7 +27425,7 @@ bool dotdot_is_supported_pump_configuration_and_control_power( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_pump_configuration_and_control_power( ++uint32_t dotdot_get_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27436,7 +27436,7 @@ int32_t dotdot_get_pump_configuration_and_control_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_POWER); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27448,7 +27448,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power ++ uint32_t new_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27461,7 +27461,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_power_undefine_reported( +@@ -27536,7 +27536,7 @@ bool dotdot_is_supported_pump_configuration_and_control_lifetime_energy_consumed + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( ++uint32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -27547,7 +27547,7 @@ int32_t dotdot_get_pump_configuration_and_control_lifetime_energy_consumed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PUMP_CONFIGURATION_AND_CONTROL_LIFETIME_ENERGY_CONSUMED); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -27559,7 +27559,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lifetime_energy_consumed ++ uint32_t new_lifetime_energy_consumed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -27572,7 +27572,7 @@ sl_status_t dotdot_set_pump_configuration_and_control_lifetime_energy_consumed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lifetime_energy_consumed, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_pump_configuration_and_control_lifetime_energy_consumed_undefine_reported( +@@ -28860,7 +28860,7 @@ bool dotdot_is_supported_thermostat_pi_cooling_demand( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_pi_cooling_demand( ++uint8_t dotdot_get_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -28871,7 +28871,7 @@ int8_t dotdot_get_thermostat_pi_cooling_demand( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_COOLING_DEMAND); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -28883,7 +28883,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pi_cooling_demand ++ uint8_t new_pi_cooling_demand + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -28896,7 +28896,7 @@ sl_status_t dotdot_set_thermostat_pi_cooling_demand( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pi_cooling_demand, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_pi_cooling_demand_undefine_reported( +@@ -28971,7 +28971,7 @@ bool dotdot_is_supported_thermostat_pi_heating_demand( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_pi_heating_demand( ++uint8_t dotdot_get_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -28982,7 +28982,7 @@ int8_t dotdot_get_thermostat_pi_heating_demand( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_PI_HEATING_DEMAND); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -28994,7 +28994,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pi_heating_demand ++ uint8_t new_pi_heating_demand + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -29007,7 +29007,7 @@ sl_status_t dotdot_set_thermostat_pi_heating_demand( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pi_heating_demand, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_pi_heating_demand_undefine_reported( +@@ -30969,7 +30969,7 @@ bool dotdot_is_supported_thermostat_number_of_weekly_transitions( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_number_of_weekly_transitions( ++uint8_t dotdot_get_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -30980,7 +30980,7 @@ int8_t dotdot_get_thermostat_number_of_weekly_transitions( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_WEEKLY_TRANSITIONS); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -30992,7 +30992,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_weekly_transitions ++ uint8_t new_number_of_weekly_transitions + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31005,7 +31005,7 @@ sl_status_t dotdot_set_thermostat_number_of_weekly_transitions( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_weekly_transitions, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_number_of_weekly_transitions_undefine_reported( +@@ -31080,7 +31080,7 @@ bool dotdot_is_supported_thermostat_number_of_daily_transitions( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_number_of_daily_transitions( ++uint8_t dotdot_get_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31091,7 +31091,7 @@ int8_t dotdot_get_thermostat_number_of_daily_transitions( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_NUMBER_OF_DAILY_TRANSITIONS); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31103,7 +31103,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_daily_transitions ++ uint8_t new_number_of_daily_transitions + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31116,7 +31116,7 @@ sl_status_t dotdot_set_thermostat_number_of_daily_transitions( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_daily_transitions, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_number_of_daily_transitions_undefine_reported( +@@ -31302,7 +31302,7 @@ bool dotdot_is_supported_thermostat_temperature_setpoint_hold_duration( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( ++uint16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31313,7 +31313,7 @@ int16_t dotdot_get_thermostat_temperature_setpoint_hold_duration( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_TEMPERATURE_SETPOINT_HOLD_DURATION); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31325,7 +31325,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_temperature_setpoint_hold_duration ++ uint16_t new_temperature_setpoint_hold_duration + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31338,7 +31338,7 @@ sl_status_t dotdot_set_thermostat_temperature_setpoint_hold_duration( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_temperature_setpoint_hold_duration, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_thermostat_temperature_setpoint_hold_duration_undefine_reported( +@@ -31857,7 +31857,7 @@ bool dotdot_is_supported_thermostat_setpoint_change_source_timestamp( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_thermostat_setpoint_change_source_timestamp( ++uint32_t dotdot_get_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31868,7 +31868,7 @@ uint8_t dotdot_get_thermostat_setpoint_change_source_timestamp( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_SETPOINT_CHANGE_SOURCE_TIMESTAMP); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31880,7 +31880,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_setpoint_change_source_timestamp ++ uint32_t new_setpoint_change_source_timestamp + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -31893,7 +31893,7 @@ sl_status_t dotdot_set_thermostat_setpoint_change_source_timestamp( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_setpoint_change_source_timestamp, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_thermostat_setpoint_change_source_timestamp_undefine_reported( +@@ -31968,7 +31968,7 @@ bool dotdot_is_supported_thermostat_occupied_setback( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_occupied_setback( ++uint8_t dotdot_get_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -31979,7 +31979,7 @@ int8_t dotdot_get_thermostat_occupied_setback( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -31991,7 +31991,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback ++ uint8_t new_occupied_setback + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32004,7 +32004,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_undefine_reported( +@@ -32079,7 +32079,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_min( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_occupied_setback_min( ++uint8_t dotdot_get_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32090,7 +32090,7 @@ int8_t dotdot_get_thermostat_occupied_setback_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MIN); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32102,7 +32102,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback_min ++ uint8_t new_occupied_setback_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32115,7 +32115,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback_min, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_min_undefine_reported( +@@ -32190,7 +32190,7 @@ bool dotdot_is_supported_thermostat_occupied_setback_max( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_occupied_setback_max( ++uint8_t dotdot_get_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32201,7 +32201,7 @@ int8_t dotdot_get_thermostat_occupied_setback_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_OCCUPIED_SETBACK_MAX); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32213,7 +32213,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_occupied_setback_max ++ uint8_t new_occupied_setback_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32226,7 +32226,7 @@ sl_status_t dotdot_set_thermostat_occupied_setback_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_occupied_setback_max, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_occupied_setback_max_undefine_reported( +@@ -32301,7 +32301,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_unoccupied_setback( ++uint8_t dotdot_get_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32312,7 +32312,7 @@ int8_t dotdot_get_thermostat_unoccupied_setback( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32324,7 +32324,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback ++ uint8_t new_unoccupied_setback + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32337,7 +32337,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_undefine_reported( +@@ -32412,7 +32412,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_min( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_unoccupied_setback_min( ++uint8_t dotdot_get_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32423,7 +32423,7 @@ int8_t dotdot_get_thermostat_unoccupied_setback_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MIN); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32435,7 +32435,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback_min ++ uint8_t new_unoccupied_setback_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32448,7 +32448,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback_min, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_min_undefine_reported( +@@ -32523,7 +32523,7 @@ bool dotdot_is_supported_thermostat_unoccupied_setback_max( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_unoccupied_setback_max( ++uint8_t dotdot_get_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32534,7 +32534,7 @@ int8_t dotdot_get_thermostat_unoccupied_setback_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_UNOCCUPIED_SETBACK_MAX); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32546,7 +32546,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_unoccupied_setback_max ++ uint8_t new_unoccupied_setback_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32559,7 +32559,7 @@ sl_status_t dotdot_set_thermostat_unoccupied_setback_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_unoccupied_setback_max, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_unoccupied_setback_max_undefine_reported( +@@ -32634,7 +32634,7 @@ bool dotdot_is_supported_thermostat_emergency_heat_delta( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_thermostat_emergency_heat_delta( ++uint8_t dotdot_get_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32645,7 +32645,7 @@ int8_t dotdot_get_thermostat_emergency_heat_delta( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_EMERGENCY_HEAT_DELTA); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32657,7 +32657,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_emergency_heat_delta ++ uint8_t new_emergency_heat_delta + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32670,7 +32670,7 @@ sl_status_t dotdot_set_thermostat_emergency_heat_delta( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_emergency_heat_delta, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_thermostat_emergency_heat_delta_undefine_reported( +@@ -32856,7 +32856,7 @@ bool dotdot_is_supported_thermostat_ac_capacity( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_thermostat_ac_capacity( ++uint16_t dotdot_get_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -32867,7 +32867,7 @@ int16_t dotdot_get_thermostat_ac_capacity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_THERMOSTAT_AC_CAPACITY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -32879,7 +32879,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_capacity ++ uint16_t new_ac_capacity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -32892,7 +32892,7 @@ sl_status_t dotdot_set_thermostat_ac_capacity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_capacity, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_thermostat_ac_capacity_undefine_reported( +@@ -34136,7 +34136,7 @@ bool dotdot_is_supported_dehumidification_control_relative_humidity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_dehumidification_control_relative_humidity( ++uint8_t dotdot_get_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34147,7 +34147,7 @@ int8_t dotdot_get_dehumidification_control_relative_humidity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RELATIVE_HUMIDITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34159,7 +34159,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_relative_humidity ++ uint8_t new_relative_humidity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34172,7 +34172,7 @@ sl_status_t dotdot_set_dehumidification_control_relative_humidity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_relative_humidity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_dehumidification_control_relative_humidity_undefine_reported( +@@ -34247,7 +34247,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_cooling( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_dehumidification_control_dehumidification_cooling( ++uint8_t dotdot_get_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34258,7 +34258,7 @@ int8_t dotdot_get_dehumidification_control_dehumidification_cooling( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_COOLING); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34270,7 +34270,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_cooling ++ uint8_t new_dehumidification_cooling + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34283,7 +34283,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_cooling( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_cooling, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_cooling_undefine_reported( +@@ -34358,7 +34358,7 @@ bool dotdot_is_supported_dehumidification_control_rh_dehumidification_setpoint( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( ++uint8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34369,7 +34369,7 @@ int8_t dotdot_get_dehumidification_control_rh_dehumidification_setpoint( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_RH_DEHUMIDIFICATION_SETPOINT); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34381,7 +34381,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_rh_dehumidification_setpoint ++ uint8_t new_rh_dehumidification_setpoint + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34394,7 +34394,7 @@ sl_status_t dotdot_set_dehumidification_control_rh_dehumidification_setpoint( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rh_dehumidification_setpoint, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_dehumidification_control_rh_dehumidification_setpoint_undefine_reported( +@@ -34691,7 +34691,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_hysteresis( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( ++uint8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34702,7 +34702,7 @@ int8_t dotdot_get_dehumidification_control_dehumidification_hysteresis( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_HYSTERESIS); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34714,7 +34714,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_hysteresis ++ uint8_t new_dehumidification_hysteresis + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34727,7 +34727,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_hysteresis( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_hysteresis, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_hysteresis_undefine_reported( +@@ -34802,7 +34802,7 @@ bool dotdot_is_supported_dehumidification_control_dehumidification_max_cool( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_dehumidification_control_dehumidification_max_cool( ++uint8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -34813,7 +34813,7 @@ int8_t dotdot_get_dehumidification_control_dehumidification_max_cool( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DEHUMIDIFICATION_CONTROL_DEHUMIDIFICATION_MAX_COOL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -34825,7 +34825,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidification_max_cool ++ uint8_t new_dehumidification_max_cool + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -34838,7 +34838,7 @@ sl_status_t dotdot_set_dehumidification_control_dehumidification_max_cool( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidification_max_cool, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_dehumidification_control_dehumidification_max_cool_undefine_reported( +@@ -35455,7 +35455,7 @@ bool dotdot_is_supported_color_control_current_hue( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_current_hue( ++uint8_t dotdot_get_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35466,7 +35466,7 @@ int8_t dotdot_get_color_control_current_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_HUE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35478,7 +35478,7 @@ sl_status_t dotdot_set_color_control_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_hue ++ uint8_t new_current_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35491,7 +35491,7 @@ sl_status_t dotdot_set_color_control_current_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_hue, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_current_hue_undefine_reported( +@@ -35566,7 +35566,7 @@ bool dotdot_is_supported_color_control_current_saturation( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_current_saturation( ++uint8_t dotdot_get_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35577,7 +35577,7 @@ int8_t dotdot_get_color_control_current_saturation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENT_SATURATION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35589,7 +35589,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_saturation ++ uint8_t new_current_saturation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35602,7 +35602,7 @@ sl_status_t dotdot_set_color_control_current_saturation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_saturation, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_current_saturation_undefine_reported( +@@ -35677,7 +35677,7 @@ bool dotdot_is_supported_color_control_remaining_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_remaining_time( ++uint16_t dotdot_get_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35688,7 +35688,7 @@ int16_t dotdot_get_color_control_remaining_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_REMAINING_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35700,7 +35700,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_remaining_time ++ uint16_t new_remaining_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35713,7 +35713,7 @@ sl_status_t dotdot_set_color_control_remaining_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_remaining_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_remaining_time_undefine_reported( +@@ -35788,7 +35788,7 @@ bool dotdot_is_supported_color_control_currentx( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_currentx( ++uint16_t dotdot_get_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35799,7 +35799,7 @@ int16_t dotdot_get_color_control_currentx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35811,7 +35811,7 @@ sl_status_t dotdot_set_color_control_currentx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_currentx ++ uint16_t new_currentx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35824,7 +35824,7 @@ sl_status_t dotdot_set_color_control_currentx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_currentx, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_currentx_undefine_reported( +@@ -35899,7 +35899,7 @@ bool dotdot_is_supported_color_control_currenty( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_currenty( ++uint16_t dotdot_get_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -35910,7 +35910,7 @@ int16_t dotdot_get_color_control_currenty( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_CURRENTY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -35922,7 +35922,7 @@ sl_status_t dotdot_set_color_control_currenty( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_currenty ++ uint16_t new_currenty + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -35935,7 +35935,7 @@ sl_status_t dotdot_set_color_control_currenty( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_currenty, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_currenty_undefine_reported( +@@ -36233,7 +36233,7 @@ bool dotdot_is_supported_color_control_color_temperature_mireds( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_temperature_mireds( ++uint16_t dotdot_get_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36244,7 +36244,7 @@ int16_t dotdot_get_color_control_color_temperature_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMPERATURE_MIREDS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36256,7 +36256,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temperature_mireds ++ uint16_t new_color_temperature_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36269,7 +36269,7 @@ sl_status_t dotdot_set_color_control_color_temperature_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temperature_mireds, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_temperature_mireds_undefine_reported( +@@ -36566,7 +36566,7 @@ bool dotdot_is_supported_color_control_number_of_primaries( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_number_of_primaries( ++uint8_t dotdot_get_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36577,7 +36577,7 @@ int8_t dotdot_get_color_control_number_of_primaries( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_NUMBER_OF_PRIMARIES); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36589,7 +36589,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_primaries ++ uint8_t new_number_of_primaries + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36602,7 +36602,7 @@ sl_status_t dotdot_set_color_control_number_of_primaries( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_primaries, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_number_of_primaries_undefine_reported( +@@ -36677,7 +36677,7 @@ bool dotdot_is_supported_color_control_primary1x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary1x( ++uint16_t dotdot_get_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36688,7 +36688,7 @@ int16_t dotdot_get_color_control_primary1x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36700,7 +36700,7 @@ sl_status_t dotdot_set_color_control_primary1x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary1x ++ uint16_t new_primary1x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36713,7 +36713,7 @@ sl_status_t dotdot_set_color_control_primary1x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary1x_undefine_reported( +@@ -36788,7 +36788,7 @@ bool dotdot_is_supported_color_control_primary1y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary1y( ++uint16_t dotdot_get_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36799,7 +36799,7 @@ int16_t dotdot_get_color_control_primary1y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36811,7 +36811,7 @@ sl_status_t dotdot_set_color_control_primary1y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary1y ++ uint16_t new_primary1y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36824,7 +36824,7 @@ sl_status_t dotdot_set_color_control_primary1y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary1y_undefine_reported( +@@ -36899,7 +36899,7 @@ bool dotdot_is_supported_color_control_primary1_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary1_intensity( ++uint8_t dotdot_get_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -36910,7 +36910,7 @@ int8_t dotdot_get_color_control_primary1_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY1_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -36922,7 +36922,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary1_intensity ++ uint8_t new_primary1_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -36935,7 +36935,7 @@ sl_status_t dotdot_set_color_control_primary1_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary1_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary1_intensity_undefine_reported( +@@ -37010,7 +37010,7 @@ bool dotdot_is_supported_color_control_primary2x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary2x( ++uint16_t dotdot_get_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37021,7 +37021,7 @@ int16_t dotdot_get_color_control_primary2x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37033,7 +37033,7 @@ sl_status_t dotdot_set_color_control_primary2x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary2x ++ uint16_t new_primary2x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37046,7 +37046,7 @@ sl_status_t dotdot_set_color_control_primary2x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary2x_undefine_reported( +@@ -37121,7 +37121,7 @@ bool dotdot_is_supported_color_control_primary2y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary2y( ++uint16_t dotdot_get_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37132,7 +37132,7 @@ int16_t dotdot_get_color_control_primary2y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37144,7 +37144,7 @@ sl_status_t dotdot_set_color_control_primary2y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary2y ++ uint16_t new_primary2y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37157,7 +37157,7 @@ sl_status_t dotdot_set_color_control_primary2y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary2y_undefine_reported( +@@ -37232,7 +37232,7 @@ bool dotdot_is_supported_color_control_primary2_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary2_intensity( ++uint8_t dotdot_get_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37243,7 +37243,7 @@ int8_t dotdot_get_color_control_primary2_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY2_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37255,7 +37255,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary2_intensity ++ uint8_t new_primary2_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37268,7 +37268,7 @@ sl_status_t dotdot_set_color_control_primary2_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary2_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary2_intensity_undefine_reported( +@@ -37343,7 +37343,7 @@ bool dotdot_is_supported_color_control_primary3x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary3x( ++uint16_t dotdot_get_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37354,7 +37354,7 @@ int16_t dotdot_get_color_control_primary3x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37366,7 +37366,7 @@ sl_status_t dotdot_set_color_control_primary3x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary3x ++ uint16_t new_primary3x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37379,7 +37379,7 @@ sl_status_t dotdot_set_color_control_primary3x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary3x_undefine_reported( +@@ -37454,7 +37454,7 @@ bool dotdot_is_supported_color_control_primary3y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary3y( ++uint16_t dotdot_get_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37465,7 +37465,7 @@ int16_t dotdot_get_color_control_primary3y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37477,7 +37477,7 @@ sl_status_t dotdot_set_color_control_primary3y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary3y ++ uint16_t new_primary3y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37490,7 +37490,7 @@ sl_status_t dotdot_set_color_control_primary3y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary3y_undefine_reported( +@@ -37565,7 +37565,7 @@ bool dotdot_is_supported_color_control_primary3_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary3_intensity( ++uint8_t dotdot_get_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37576,7 +37576,7 @@ int8_t dotdot_get_color_control_primary3_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY3_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37588,7 +37588,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary3_intensity ++ uint8_t new_primary3_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37601,7 +37601,7 @@ sl_status_t dotdot_set_color_control_primary3_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary3_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary3_intensity_undefine_reported( +@@ -37676,7 +37676,7 @@ bool dotdot_is_supported_color_control_primary4x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary4x( ++uint16_t dotdot_get_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37687,7 +37687,7 @@ int16_t dotdot_get_color_control_primary4x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37699,7 +37699,7 @@ sl_status_t dotdot_set_color_control_primary4x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary4x ++ uint16_t new_primary4x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37712,7 +37712,7 @@ sl_status_t dotdot_set_color_control_primary4x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary4x_undefine_reported( +@@ -37787,7 +37787,7 @@ bool dotdot_is_supported_color_control_primary4y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary4y( ++uint16_t dotdot_get_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37798,7 +37798,7 @@ int16_t dotdot_get_color_control_primary4y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37810,7 +37810,7 @@ sl_status_t dotdot_set_color_control_primary4y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary4y ++ uint16_t new_primary4y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37823,7 +37823,7 @@ sl_status_t dotdot_set_color_control_primary4y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary4y_undefine_reported( +@@ -37898,7 +37898,7 @@ bool dotdot_is_supported_color_control_primary4_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary4_intensity( ++uint8_t dotdot_get_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -37909,7 +37909,7 @@ int8_t dotdot_get_color_control_primary4_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY4_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -37921,7 +37921,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary4_intensity ++ uint8_t new_primary4_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -37934,7 +37934,7 @@ sl_status_t dotdot_set_color_control_primary4_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary4_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary4_intensity_undefine_reported( +@@ -38009,7 +38009,7 @@ bool dotdot_is_supported_color_control_primary5x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary5x( ++uint16_t dotdot_get_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38020,7 +38020,7 @@ int16_t dotdot_get_color_control_primary5x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38032,7 +38032,7 @@ sl_status_t dotdot_set_color_control_primary5x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary5x ++ uint16_t new_primary5x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38045,7 +38045,7 @@ sl_status_t dotdot_set_color_control_primary5x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary5x_undefine_reported( +@@ -38120,7 +38120,7 @@ bool dotdot_is_supported_color_control_primary5y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary5y( ++uint16_t dotdot_get_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38131,7 +38131,7 @@ int16_t dotdot_get_color_control_primary5y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38143,7 +38143,7 @@ sl_status_t dotdot_set_color_control_primary5y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary5y ++ uint16_t new_primary5y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38156,7 +38156,7 @@ sl_status_t dotdot_set_color_control_primary5y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary5y_undefine_reported( +@@ -38231,7 +38231,7 @@ bool dotdot_is_supported_color_control_primary5_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary5_intensity( ++uint8_t dotdot_get_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38242,7 +38242,7 @@ int8_t dotdot_get_color_control_primary5_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY5_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38254,7 +38254,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary5_intensity ++ uint8_t new_primary5_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38267,7 +38267,7 @@ sl_status_t dotdot_set_color_control_primary5_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary5_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary5_intensity_undefine_reported( +@@ -38342,7 +38342,7 @@ bool dotdot_is_supported_color_control_primary6x( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary6x( ++uint16_t dotdot_get_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38353,7 +38353,7 @@ int16_t dotdot_get_color_control_primary6x( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6X); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38365,7 +38365,7 @@ sl_status_t dotdot_set_color_control_primary6x( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary6x ++ uint16_t new_primary6x + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38378,7 +38378,7 @@ sl_status_t dotdot_set_color_control_primary6x( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6x, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary6x_undefine_reported( +@@ -38453,7 +38453,7 @@ bool dotdot_is_supported_color_control_primary6y( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_primary6y( ++uint16_t dotdot_get_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38464,7 +38464,7 @@ int16_t dotdot_get_color_control_primary6y( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6Y); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38476,7 +38476,7 @@ sl_status_t dotdot_set_color_control_primary6y( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_primary6y ++ uint16_t new_primary6y + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38489,7 +38489,7 @@ sl_status_t dotdot_set_color_control_primary6y( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6y, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_primary6y_undefine_reported( +@@ -38564,7 +38564,7 @@ bool dotdot_is_supported_color_control_primary6_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_primary6_intensity( ++uint8_t dotdot_get_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38575,7 +38575,7 @@ int8_t dotdot_get_color_control_primary6_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_PRIMARY6_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38587,7 +38587,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_primary6_intensity ++ uint8_t new_primary6_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38600,7 +38600,7 @@ sl_status_t dotdot_set_color_control_primary6_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_primary6_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_primary6_intensity_undefine_reported( +@@ -38675,7 +38675,7 @@ bool dotdot_is_supported_color_control_white_pointx( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_white_pointx( ++uint16_t dotdot_get_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38686,7 +38686,7 @@ int16_t dotdot_get_color_control_white_pointx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38698,7 +38698,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_white_pointx ++ uint16_t new_white_pointx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38711,7 +38711,7 @@ sl_status_t dotdot_set_color_control_white_pointx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_white_pointx, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_white_pointx_undefine_reported( +@@ -38786,7 +38786,7 @@ bool dotdot_is_supported_color_control_white_pointy( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_white_pointy( ++uint16_t dotdot_get_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38797,7 +38797,7 @@ int16_t dotdot_get_color_control_white_pointy( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_WHITE_POINTY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38809,7 +38809,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_white_pointy ++ uint16_t new_white_pointy + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38822,7 +38822,7 @@ sl_status_t dotdot_set_color_control_white_pointy( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_white_pointy, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_white_pointy_undefine_reported( +@@ -38897,7 +38897,7 @@ bool dotdot_is_supported_color_control_color_pointrx( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointrx( ++uint16_t dotdot_get_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -38908,7 +38908,7 @@ int16_t dotdot_get_color_control_color_pointrx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -38920,7 +38920,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointrx ++ uint16_t new_color_pointrx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -38933,7 +38933,7 @@ sl_status_t dotdot_set_color_control_color_pointrx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointrx, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointrx_undefine_reported( +@@ -39008,7 +39008,7 @@ bool dotdot_is_supported_color_control_color_pointry( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointry( ++uint16_t dotdot_get_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39019,7 +39019,7 @@ int16_t dotdot_get_color_control_color_pointry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTRY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39031,7 +39031,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointry ++ uint16_t new_color_pointry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39044,7 +39044,7 @@ sl_status_t dotdot_set_color_control_color_pointry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointry, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointry_undefine_reported( +@@ -39119,7 +39119,7 @@ bool dotdot_is_supported_color_control_color_pointr_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_color_pointr_intensity( ++uint8_t dotdot_get_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39130,7 +39130,7 @@ int8_t dotdot_get_color_control_color_pointr_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTR_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39142,7 +39142,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointr_intensity ++ uint8_t new_color_pointr_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39155,7 +39155,7 @@ sl_status_t dotdot_set_color_control_color_pointr_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointr_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_color_pointr_intensity_undefine_reported( +@@ -39230,7 +39230,7 @@ bool dotdot_is_supported_color_control_color_pointgx( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointgx( ++uint16_t dotdot_get_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39241,7 +39241,7 @@ int16_t dotdot_get_color_control_color_pointgx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39253,7 +39253,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointgx ++ uint16_t new_color_pointgx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39266,7 +39266,7 @@ sl_status_t dotdot_set_color_control_color_pointgx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointgx, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointgx_undefine_reported( +@@ -39341,7 +39341,7 @@ bool dotdot_is_supported_color_control_color_pointgy( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointgy( ++uint16_t dotdot_get_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39352,7 +39352,7 @@ int16_t dotdot_get_color_control_color_pointgy( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTGY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39364,7 +39364,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointgy ++ uint16_t new_color_pointgy + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39377,7 +39377,7 @@ sl_status_t dotdot_set_color_control_color_pointgy( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointgy, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointgy_undefine_reported( +@@ -39452,7 +39452,7 @@ bool dotdot_is_supported_color_control_color_pointg_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_color_pointg_intensity( ++uint8_t dotdot_get_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39463,7 +39463,7 @@ int8_t dotdot_get_color_control_color_pointg_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTG_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39475,7 +39475,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointg_intensity ++ uint8_t new_color_pointg_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39488,7 +39488,7 @@ sl_status_t dotdot_set_color_control_color_pointg_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointg_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_color_pointg_intensity_undefine_reported( +@@ -39563,7 +39563,7 @@ bool dotdot_is_supported_color_control_color_pointbx( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointbx( ++uint16_t dotdot_get_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39574,7 +39574,7 @@ int16_t dotdot_get_color_control_color_pointbx( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39586,7 +39586,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointbx ++ uint16_t new_color_pointbx + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39599,7 +39599,7 @@ sl_status_t dotdot_set_color_control_color_pointbx( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointbx, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointbx_undefine_reported( +@@ -39674,7 +39674,7 @@ bool dotdot_is_supported_color_control_color_pointby( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_pointby( ++uint16_t dotdot_get_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39685,7 +39685,7 @@ int16_t dotdot_get_color_control_color_pointby( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTBY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39697,7 +39697,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_pointby ++ uint16_t new_color_pointby + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39710,7 +39710,7 @@ sl_status_t dotdot_set_color_control_color_pointby( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointby, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_pointby_undefine_reported( +@@ -39785,7 +39785,7 @@ bool dotdot_is_supported_color_control_color_pointb_intensity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_color_pointb_intensity( ++uint8_t dotdot_get_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39796,7 +39796,7 @@ int8_t dotdot_get_color_control_color_pointb_intensity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_POINTB_INTENSITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39808,7 +39808,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_pointb_intensity ++ uint8_t new_color_pointb_intensity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39821,7 +39821,7 @@ sl_status_t dotdot_set_color_control_color_pointb_intensity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_pointb_intensity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_color_pointb_intensity_undefine_reported( +@@ -39896,7 +39896,7 @@ bool dotdot_is_supported_color_control_enhanced_current_hue( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_enhanced_current_hue( ++uint16_t dotdot_get_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -39907,7 +39907,7 @@ int16_t dotdot_get_color_control_enhanced_current_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_ENHANCED_CURRENT_HUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -39919,7 +39919,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_enhanced_current_hue ++ uint16_t new_enhanced_current_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -39932,7 +39932,7 @@ sl_status_t dotdot_set_color_control_enhanced_current_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_enhanced_current_hue, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_enhanced_current_hue_undefine_reported( +@@ -40118,7 +40118,7 @@ bool dotdot_is_supported_color_control_color_loop_active( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_color_loop_active( ++uint8_t dotdot_get_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40129,7 +40129,7 @@ int8_t dotdot_get_color_control_color_loop_active( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_ACTIVE); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40141,7 +40141,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_loop_active ++ uint8_t new_color_loop_active + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40154,7 +40154,7 @@ sl_status_t dotdot_set_color_control_color_loop_active( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_active, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_color_loop_active_undefine_reported( +@@ -40229,7 +40229,7 @@ bool dotdot_is_supported_color_control_color_loop_direction( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_color_control_color_loop_direction( ++uint8_t dotdot_get_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40240,7 +40240,7 @@ int8_t dotdot_get_color_control_color_loop_direction( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_DIRECTION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40252,7 +40252,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_color_loop_direction ++ uint8_t new_color_loop_direction + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40265,7 +40265,7 @@ sl_status_t dotdot_set_color_control_color_loop_direction( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_direction, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_color_control_color_loop_direction_undefine_reported( +@@ -40340,7 +40340,7 @@ bool dotdot_is_supported_color_control_color_loop_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_loop_time( ++uint16_t dotdot_get_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40351,7 +40351,7 @@ int16_t dotdot_get_color_control_color_loop_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40363,7 +40363,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_time ++ uint16_t new_color_loop_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40376,7 +40376,7 @@ sl_status_t dotdot_set_color_control_color_loop_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_loop_time_undefine_reported( +@@ -40451,7 +40451,7 @@ bool dotdot_is_supported_color_control_color_loop_start_enhanced_hue( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_loop_start_enhanced_hue( ++uint16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40462,7 +40462,7 @@ int16_t dotdot_get_color_control_color_loop_start_enhanced_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_START_ENHANCED_HUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40474,7 +40474,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_start_enhanced_hue ++ uint16_t new_color_loop_start_enhanced_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40487,7 +40487,7 @@ sl_status_t dotdot_set_color_control_color_loop_start_enhanced_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_start_enhanced_hue, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_loop_start_enhanced_hue_undefine_reported( +@@ -40562,7 +40562,7 @@ bool dotdot_is_supported_color_control_color_loop_stored_enhanced_hue( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( ++uint16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40573,7 +40573,7 @@ int16_t dotdot_get_color_control_color_loop_stored_enhanced_hue( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_LOOP_STORED_ENHANCED_HUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40585,7 +40585,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_loop_stored_enhanced_hue ++ uint16_t new_color_loop_stored_enhanced_hue + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40598,7 +40598,7 @@ sl_status_t dotdot_set_color_control_color_loop_stored_enhanced_hue( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_loop_stored_enhanced_hue, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_loop_stored_enhanced_hue_undefine_reported( +@@ -40784,7 +40784,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_min_mireds( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_temp_physical_min_mireds( ++uint16_t dotdot_get_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40795,7 +40795,7 @@ int16_t dotdot_get_color_control_color_temp_physical_min_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MIN_MIREDS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40807,7 +40807,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temp_physical_min_mireds ++ uint16_t new_color_temp_physical_min_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40820,7 +40820,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_min_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temp_physical_min_mireds, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_temp_physical_min_mireds_undefine_reported( +@@ -40895,7 +40895,7 @@ bool dotdot_is_supported_color_control_color_temp_physical_max_mireds( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_color_temp_physical_max_mireds( ++uint16_t dotdot_get_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -40906,7 +40906,7 @@ int16_t dotdot_get_color_control_color_temp_physical_max_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COLOR_TEMP_PHYSICAL_MAX_MIREDS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -40918,7 +40918,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_color_temp_physical_max_mireds ++ uint16_t new_color_temp_physical_max_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -40931,7 +40931,7 @@ sl_status_t dotdot_set_color_control_color_temp_physical_max_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_color_temp_physical_max_mireds, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_color_temp_physical_max_mireds_undefine_reported( +@@ -41006,7 +41006,7 @@ bool dotdot_is_supported_color_control_couple_color_temp_to_level_min_mireds( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( ++uint16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41017,7 +41017,7 @@ int16_t dotdot_get_color_control_couple_color_temp_to_level_min_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_COUPLE_COLOR_TEMP_TO_LEVEL_MIN_MIREDS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41029,7 +41029,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_couple_color_temp_to_level_min_mireds ++ uint16_t new_couple_color_temp_to_level_min_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41042,7 +41042,7 @@ sl_status_t dotdot_set_color_control_couple_color_temp_to_level_min_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_couple_color_temp_to_level_min_mireds, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_couple_color_temp_to_level_min_mireds_undefine_reported( +@@ -41117,7 +41117,7 @@ bool dotdot_is_supported_color_control_start_up_color_temperature_mireds( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_color_control_start_up_color_temperature_mireds( ++uint16_t dotdot_get_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41128,7 +41128,7 @@ int16_t dotdot_get_color_control_start_up_color_temperature_mireds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_COLOR_CONTROL_START_UP_COLOR_TEMPERATURE_MIREDS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41140,7 +41140,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_start_up_color_temperature_mireds ++ uint16_t new_start_up_color_temperature_mireds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41153,7 +41153,7 @@ sl_status_t dotdot_set_color_control_start_up_color_temperature_mireds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_start_up_color_temperature_mireds, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_color_control_start_up_color_temperature_mireds_undefine_reported( +@@ -41442,7 +41442,7 @@ bool dotdot_is_supported_ballast_configuration_physical_min_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_physical_min_level( ++uint8_t dotdot_get_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41453,7 +41453,7 @@ int8_t dotdot_get_ballast_configuration_physical_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MIN_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41465,7 +41465,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_min_level ++ uint8_t new_physical_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41478,7 +41478,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_min_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_physical_min_level_undefine_reported( +@@ -41553,7 +41553,7 @@ bool dotdot_is_supported_ballast_configuration_physical_max_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_physical_max_level( ++uint8_t dotdot_get_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41564,7 +41564,7 @@ int8_t dotdot_get_ballast_configuration_physical_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_PHYSICAL_MAX_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41576,7 +41576,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_max_level ++ uint8_t new_physical_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41589,7 +41589,7 @@ sl_status_t dotdot_set_ballast_configuration_physical_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_max_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_physical_max_level_undefine_reported( +@@ -41775,7 +41775,7 @@ bool dotdot_is_supported_ballast_configuration_min_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_min_level( ++uint8_t dotdot_get_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41786,7 +41786,7 @@ int8_t dotdot_get_ballast_configuration_min_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MIN_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41798,7 +41798,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_min_level ++ uint8_t new_min_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41811,7 +41811,7 @@ sl_status_t dotdot_set_ballast_configuration_min_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_min_level_undefine_reported( +@@ -41886,7 +41886,7 @@ bool dotdot_is_supported_ballast_configuration_max_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_max_level( ++uint8_t dotdot_get_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -41897,7 +41897,7 @@ int8_t dotdot_get_ballast_configuration_max_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_MAX_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -41909,7 +41909,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_max_level ++ uint8_t new_max_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -41922,7 +41922,7 @@ sl_status_t dotdot_set_ballast_configuration_max_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_max_level_undefine_reported( +@@ -41997,7 +41997,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_power_on_level( ++uint8_t dotdot_get_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42008,7 +42008,7 @@ int8_t dotdot_get_ballast_configuration_power_on_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42020,7 +42020,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_power_on_level ++ uint8_t new_power_on_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42033,7 +42033,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_on_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_power_on_level_undefine_reported( +@@ -42108,7 +42108,7 @@ bool dotdot_is_supported_ballast_configuration_power_on_fade_time( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_ballast_configuration_power_on_fade_time( ++uint16_t dotdot_get_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42119,7 +42119,7 @@ int16_t dotdot_get_ballast_configuration_power_on_fade_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_POWER_ON_FADE_TIME); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42131,7 +42131,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_power_on_fade_time ++ uint16_t new_power_on_fade_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42144,7 +42144,7 @@ sl_status_t dotdot_set_ballast_configuration_power_on_fade_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_on_fade_time, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_ballast_configuration_power_on_fade_time_undefine_reported( +@@ -42219,7 +42219,7 @@ bool dotdot_is_supported_ballast_configuration_intrinsic_ballast_factor( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( ++uint8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42230,7 +42230,7 @@ int8_t dotdot_get_ballast_configuration_intrinsic_ballast_factor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_INTRINSIC_BALLAST_FACTOR); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42242,7 +42242,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_intrinsic_ballast_factor ++ uint8_t new_intrinsic_ballast_factor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42255,7 +42255,7 @@ sl_status_t dotdot_set_ballast_configuration_intrinsic_ballast_factor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_intrinsic_ballast_factor, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_intrinsic_ballast_factor_undefine_reported( +@@ -42330,7 +42330,7 @@ bool dotdot_is_supported_ballast_configuration_ballast_factor_adjustment( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( ++uint8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42341,7 +42341,7 @@ int8_t dotdot_get_ballast_configuration_ballast_factor_adjustment( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_BALLAST_FACTOR_ADJUSTMENT); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42353,7 +42353,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_ballast_factor_adjustment ++ uint8_t new_ballast_factor_adjustment + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42366,7 +42366,7 @@ sl_status_t dotdot_set_ballast_configuration_ballast_factor_adjustment( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ballast_factor_adjustment, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_ballast_factor_adjustment_undefine_reported( +@@ -42441,7 +42441,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_quantity( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ballast_configuration_lamp_quantity( ++uint8_t dotdot_get_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42452,7 +42452,7 @@ int8_t dotdot_get_ballast_configuration_lamp_quantity( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_QUANTITY); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42464,7 +42464,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_lamp_quantity ++ uint8_t new_lamp_quantity + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42477,7 +42477,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_quantity( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_quantity, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_quantity_undefine_reported( +@@ -42776,7 +42776,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_rated_hours( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_ballast_configuration_lamp_rated_hours( ++uint32_t dotdot_get_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42787,7 +42787,7 @@ int32_t dotdot_get_ballast_configuration_lamp_rated_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_RATED_HOURS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42799,7 +42799,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_rated_hours ++ uint32_t new_lamp_rated_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42812,7 +42812,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_rated_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_rated_hours, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_rated_hours_undefine_reported( +@@ -42887,7 +42887,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_ballast_configuration_lamp_burn_hours( ++uint32_t dotdot_get_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -42898,7 +42898,7 @@ int32_t dotdot_get_ballast_configuration_lamp_burn_hours( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -42910,7 +42910,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_burn_hours ++ uint32_t new_lamp_burn_hours + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -42923,7 +42923,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_burn_hours, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_burn_hours_undefine_reported( +@@ -43109,7 +43109,7 @@ bool dotdot_is_supported_ballast_configuration_lamp_burn_hours_trip_point( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( ++uint32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43120,7 +43120,7 @@ int32_t dotdot_get_ballast_configuration_lamp_burn_hours_trip_point( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_BALLAST_CONFIGURATION_LAMP_BURN_HOURS_TRIP_POINT); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43132,7 +43132,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_lamp_burn_hours_trip_point ++ uint32_t new_lamp_burn_hours_trip_point + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43145,7 +43145,7 @@ sl_status_t dotdot_set_ballast_configuration_lamp_burn_hours_trip_point( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_lamp_burn_hours_trip_point, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_ballast_configuration_lamp_burn_hours_trip_point_undefine_reported( +@@ -43323,7 +43323,7 @@ bool dotdot_is_supported_illuminance_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_illuminance_measurement_measured_value( ++uint16_t dotdot_get_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43334,7 +43334,7 @@ int16_t dotdot_get_illuminance_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43346,7 +43346,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43359,7 +43359,7 @@ sl_status_t dotdot_set_illuminance_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_illuminance_measurement_measured_value_undefine_reported( +@@ -43434,7 +43434,7 @@ bool dotdot_is_supported_illuminance_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_illuminance_measurement_min_measured_value( ++uint16_t dotdot_get_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43445,7 +43445,7 @@ int16_t dotdot_get_illuminance_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43457,7 +43457,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43470,7 +43470,7 @@ sl_status_t dotdot_set_illuminance_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_illuminance_measurement_min_measured_value_undefine_reported( +@@ -43545,7 +43545,7 @@ bool dotdot_is_supported_illuminance_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_illuminance_measurement_max_measured_value( ++uint16_t dotdot_get_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43556,7 +43556,7 @@ int16_t dotdot_get_illuminance_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43568,7 +43568,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43581,7 +43581,7 @@ sl_status_t dotdot_set_illuminance_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_illuminance_measurement_max_measured_value_undefine_reported( +@@ -43656,7 +43656,7 @@ bool dotdot_is_supported_illuminance_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_illuminance_measurement_tolerance( ++uint16_t dotdot_get_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -43667,7 +43667,7 @@ int16_t dotdot_get_illuminance_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -43679,7 +43679,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -43692,7 +43692,7 @@ sl_status_t dotdot_set_illuminance_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_illuminance_measurement_tolerance_undefine_reported( +@@ -44134,7 +44134,7 @@ bool dotdot_is_supported_illuminance_level_sensing_illuminance_target_level( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( ++uint16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -44145,7 +44145,7 @@ int16_t dotdot_get_illuminance_level_sensing_illuminance_target_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ILLUMINANCE_LEVEL_SENSING_ILLUMINANCE_TARGET_LEVEL); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -44157,7 +44157,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_illuminance_target_level ++ uint16_t new_illuminance_target_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -44170,7 +44170,7 @@ sl_status_t dotdot_set_illuminance_level_sensing_illuminance_target_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_illuminance_target_level, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_illuminance_level_sensing_illuminance_target_level_undefine_reported( +@@ -44609,7 +44609,7 @@ bool dotdot_is_supported_temperature_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_temperature_measurement_tolerance( ++uint16_t dotdot_get_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -44620,7 +44620,7 @@ int16_t dotdot_get_temperature_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_TEMPERATURE_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -44632,7 +44632,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -44645,7 +44645,7 @@ sl_status_t dotdot_set_temperature_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_temperature_measurement_tolerance_undefine_reported( +@@ -45084,7 +45084,7 @@ bool dotdot_is_supported_pressure_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pressure_measurement_tolerance( ++uint16_t dotdot_get_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45095,7 +45095,7 @@ int16_t dotdot_get_pressure_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45107,7 +45107,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45120,7 +45120,7 @@ sl_status_t dotdot_set_pressure_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pressure_measurement_tolerance_undefine_reported( +@@ -45528,7 +45528,7 @@ bool dotdot_is_supported_pressure_measurement_scaled_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_pressure_measurement_scaled_tolerance( ++uint16_t dotdot_get_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45539,7 +45539,7 @@ int16_t dotdot_get_pressure_measurement_scaled_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PRESSURE_MEASUREMENT_SCALED_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45551,7 +45551,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_scaled_tolerance ++ uint16_t new_scaled_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45564,7 +45564,7 @@ sl_status_t dotdot_set_pressure_measurement_scaled_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_scaled_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_pressure_measurement_scaled_tolerance_undefine_reported( +@@ -45796,7 +45796,7 @@ bool dotdot_is_supported_flow_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_flow_measurement_measured_value( ++uint16_t dotdot_get_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45807,7 +45807,7 @@ int16_t dotdot_get_flow_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45819,7 +45819,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45832,7 +45832,7 @@ sl_status_t dotdot_set_flow_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_flow_measurement_measured_value_undefine_reported( +@@ -45907,7 +45907,7 @@ bool dotdot_is_supported_flow_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_flow_measurement_min_measured_value( ++uint16_t dotdot_get_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -45918,7 +45918,7 @@ int16_t dotdot_get_flow_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -45930,7 +45930,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -45943,7 +45943,7 @@ sl_status_t dotdot_set_flow_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_flow_measurement_min_measured_value_undefine_reported( +@@ -46018,7 +46018,7 @@ bool dotdot_is_supported_flow_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_flow_measurement_max_measured_value( ++uint16_t dotdot_get_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46029,7 +46029,7 @@ int16_t dotdot_get_flow_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46041,7 +46041,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46054,7 +46054,7 @@ sl_status_t dotdot_set_flow_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_flow_measurement_max_measured_value_undefine_reported( +@@ -46129,7 +46129,7 @@ bool dotdot_is_supported_flow_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_flow_measurement_tolerance( ++uint16_t dotdot_get_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46140,7 +46140,7 @@ int16_t dotdot_get_flow_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_FLOW_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46152,7 +46152,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46165,7 +46165,7 @@ sl_status_t dotdot_set_flow_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_flow_measurement_tolerance_undefine_reported( +@@ -46271,7 +46271,7 @@ bool dotdot_is_supported_relativity_humidity_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_relativity_humidity_measured_value( ++uint16_t dotdot_get_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46282,7 +46282,7 @@ int16_t dotdot_get_relativity_humidity_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46294,7 +46294,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46307,7 +46307,7 @@ sl_status_t dotdot_set_relativity_humidity_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_relativity_humidity_measured_value_undefine_reported( +@@ -46382,7 +46382,7 @@ bool dotdot_is_supported_relativity_humidity_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_relativity_humidity_min_measured_value( ++uint16_t dotdot_get_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46393,7 +46393,7 @@ int16_t dotdot_get_relativity_humidity_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46405,7 +46405,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46418,7 +46418,7 @@ sl_status_t dotdot_set_relativity_humidity_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_relativity_humidity_min_measured_value_undefine_reported( +@@ -46493,7 +46493,7 @@ bool dotdot_is_supported_relativity_humidity_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_relativity_humidity_max_measured_value( ++uint16_t dotdot_get_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46504,7 +46504,7 @@ int16_t dotdot_get_relativity_humidity_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46516,7 +46516,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46529,7 +46529,7 @@ sl_status_t dotdot_set_relativity_humidity_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_relativity_humidity_max_measured_value_undefine_reported( +@@ -46604,7 +46604,7 @@ bool dotdot_is_supported_relativity_humidity_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_relativity_humidity_tolerance( ++uint16_t dotdot_get_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -46615,7 +46615,7 @@ int16_t dotdot_get_relativity_humidity_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_RELATIVITY_HUMIDITY_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -46627,7 +46627,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -46640,7 +46640,7 @@ sl_status_t dotdot_set_relativity_humidity_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_relativity_humidity_tolerance_undefine_reported( +@@ -47079,7 +47079,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_occupied_to_unoccupied_delay( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47090,7 +47090,7 @@ int16_t dotdot_get_occupancy_sensing_pir_occupied_to_unoccupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47102,7 +47102,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_pir_occupied_to_unoccupied_delay ++ uint16_t new_pir_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47115,7 +47115,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_occupied_to_unoccupied_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_occupied_to_unoccupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_occupied_to_unoccupied_delay_undefine_reported( +@@ -47190,7 +47190,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_delay( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47201,7 +47201,7 @@ int16_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47213,7 +47213,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_pir_unoccupied_to_occupied_delay ++ uint16_t new_pir_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47226,7 +47226,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_unoccupied_to_occupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_unoccupied_to_occupied_delay_undefine_reported( +@@ -47301,7 +47301,7 @@ bool dotdot_is_supported_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47312,7 +47312,7 @@ int8_t dotdot_get_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PIR_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47324,7 +47324,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_pir_unoccupied_to_occupied_threshold ++ uint8_t new_pir_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47337,7 +47337,7 @@ sl_status_t dotdot_set_occupancy_sensing_pir_unoccupied_to_occupied_threshold( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_pir_unoccupied_to_occupied_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_occupancy_sensing_pir_unoccupied_to_occupied_threshold_undefine_reported( +@@ -47412,7 +47412,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_occupied_to_unoccupied_del + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47423,7 +47423,7 @@ int16_t dotdot_get_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47435,7 +47435,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ultrasonic_occupied_to_unoccupied_delay ++ uint16_t new_ultrasonic_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47448,7 +47448,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_occupied_to_unoccupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_occupied_to_unoccupied_delay_undefine_reported( +@@ -47523,7 +47523,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_del + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47534,7 +47534,7 @@ int16_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47546,7 +47546,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ultrasonic_unoccupied_to_occupied_delay ++ uint16_t new_ultrasonic_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47559,7 +47559,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_unoccupied_to_occupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_delay_undefine_reported( +@@ -47634,7 +47634,7 @@ bool dotdot_is_supported_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thr + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47645,7 +47645,7 @@ int8_t dotdot_get_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_ULTRASONIC_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47657,7 +47657,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_ultrasonic_unoccupied_to_occupied_threshold ++ uint8_t new_ultrasonic_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47670,7 +47670,7 @@ sl_status_t dotdot_set_occupancy_sensing_ultrasonic_unoccupied_to_occupied_thres + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ultrasonic_unoccupied_to_occupied_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_occupancy_sensing_ultrasonic_unoccupied_to_occupied_threshold_undefine_reported( +@@ -47745,7 +47745,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_occupied_to_unoccupi + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( ++uint16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47756,7 +47756,7 @@ int16_t dotdot_get_occupancy_sensing_physical_contact_occupied_to_unoccupied_del + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_OCCUPIED_TO_UNOCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47768,7 +47768,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_contact_occupied_to_unoccupied_delay ++ uint16_t new_physical_contact_occupied_to_unoccupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47781,7 +47781,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_occupied_to_unoccupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_occupied_to_unoccupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_occupied_to_unoccupied_delay_undefine_reported( +@@ -47856,7 +47856,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( ++uint16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47867,7 +47867,7 @@ int16_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_del + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_DELAY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47879,7 +47879,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_physical_contact_unoccupied_to_occupied_delay ++ uint16_t new_physical_contact_unoccupied_to_occupied_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -47892,7 +47892,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_unoccupied_to_occupied_delay, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_delay_undefine_reported( +@@ -47967,7 +47967,7 @@ bool dotdot_is_supported_occupancy_sensing_physical_contact_unoccupied_to_occupi + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( ++uint8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -47978,7 +47978,7 @@ int8_t dotdot_get_occupancy_sensing_physical_contact_unoccupied_to_occupied_thre + endpoint_node, + DOTDOT_ATTRIBUTE_ID_OCCUPANCY_SENSING_PHYSICAL_CONTACT_UNOCCUPIED_TO_OCCUPIED_THRESHOLD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -47990,7 +47990,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_physical_contact_unoccupied_to_occupied_threshold ++ uint8_t new_physical_contact_unoccupied_to_occupied_threshold + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48003,7 +48003,7 @@ sl_status_t dotdot_set_occupancy_sensing_physical_contact_unoccupied_to_occupied + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_physical_contact_unoccupied_to_occupied_threshold, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_occupancy_sensing_physical_contact_unoccupied_to_occupied_threshold_undefine_reported( +@@ -48160,7 +48160,7 @@ bool dotdot_is_supported_soil_moisture_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_soil_moisture_measured_value( ++uint16_t dotdot_get_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48171,7 +48171,7 @@ int16_t dotdot_get_soil_moisture_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48183,7 +48183,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48196,7 +48196,7 @@ sl_status_t dotdot_set_soil_moisture_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_soil_moisture_measured_value_undefine_reported( +@@ -48271,7 +48271,7 @@ bool dotdot_is_supported_soil_moisture_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_soil_moisture_min_measured_value( ++uint16_t dotdot_get_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48282,7 +48282,7 @@ int16_t dotdot_get_soil_moisture_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48294,7 +48294,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48307,7 +48307,7 @@ sl_status_t dotdot_set_soil_moisture_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_soil_moisture_min_measured_value_undefine_reported( +@@ -48382,7 +48382,7 @@ bool dotdot_is_supported_soil_moisture_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_soil_moisture_max_measured_value( ++uint16_t dotdot_get_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48393,7 +48393,7 @@ int16_t dotdot_get_soil_moisture_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48405,7 +48405,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48418,7 +48418,7 @@ sl_status_t dotdot_set_soil_moisture_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_soil_moisture_max_measured_value_undefine_reported( +@@ -48493,7 +48493,7 @@ bool dotdot_is_supported_soil_moisture_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_soil_moisture_tolerance( ++uint16_t dotdot_get_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48504,7 +48504,7 @@ int16_t dotdot_get_soil_moisture_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SOIL_MOISTURE_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48516,7 +48516,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48529,7 +48529,7 @@ sl_status_t dotdot_set_soil_moisture_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_soil_moisture_tolerance_undefine_reported( +@@ -48635,7 +48635,7 @@ bool dotdot_is_supported_ph_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_ph_measurement_measured_value( ++uint16_t dotdot_get_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48646,7 +48646,7 @@ int16_t dotdot_get_ph_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48658,7 +48658,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48671,7 +48671,7 @@ sl_status_t dotdot_set_ph_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_ph_measurement_measured_value_undefine_reported( +@@ -48746,7 +48746,7 @@ bool dotdot_is_supported_ph_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_ph_measurement_min_measured_value( ++uint16_t dotdot_get_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48757,7 +48757,7 @@ int16_t dotdot_get_ph_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48769,7 +48769,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48782,7 +48782,7 @@ sl_status_t dotdot_set_ph_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_ph_measurement_min_measured_value_undefine_reported( +@@ -48857,7 +48857,7 @@ bool dotdot_is_supported_ph_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_ph_measurement_max_measured_value( ++uint16_t dotdot_get_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48868,7 +48868,7 @@ int16_t dotdot_get_ph_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48880,7 +48880,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -48893,7 +48893,7 @@ sl_status_t dotdot_set_ph_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_ph_measurement_max_measured_value_undefine_reported( +@@ -48968,7 +48968,7 @@ bool dotdot_is_supported_ph_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_ph_measurement_tolerance( ++uint16_t dotdot_get_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -48979,7 +48979,7 @@ int16_t dotdot_get_ph_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_PH_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -48991,7 +48991,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49004,7 +49004,7 @@ sl_status_t dotdot_set_ph_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_ph_measurement_tolerance_undefine_reported( +@@ -49110,7 +49110,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_conductivity_measurement_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49121,7 +49121,7 @@ int16_t dotdot_get_electrical_conductivity_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49133,7 +49133,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49146,7 +49146,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_measured_value_undefine_reported( +@@ -49221,7 +49221,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49232,7 +49232,7 @@ int16_t dotdot_get_electrical_conductivity_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49244,7 +49244,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49257,7 +49257,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_min_measured_value_undefine_reported( +@@ -49332,7 +49332,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( ++uint16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49343,7 +49343,7 @@ int16_t dotdot_get_electrical_conductivity_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49355,7 +49355,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49368,7 +49368,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_max_measured_value_undefine_reported( +@@ -49443,7 +49443,7 @@ bool dotdot_is_supported_electrical_conductivity_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_conductivity_measurement_tolerance( ++uint16_t dotdot_get_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49454,7 +49454,7 @@ int16_t dotdot_get_electrical_conductivity_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_CONDUCTIVITY_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49466,7 +49466,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49479,7 +49479,7 @@ sl_status_t dotdot_set_electrical_conductivity_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_conductivity_measurement_tolerance_undefine_reported( +@@ -49585,7 +49585,7 @@ bool dotdot_is_supported_wind_speed_measurement_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_wind_speed_measurement_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49596,7 +49596,7 @@ int16_t dotdot_get_wind_speed_measurement_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49608,7 +49608,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_measured_value ++ uint16_t new_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49621,7 +49621,7 @@ sl_status_t dotdot_set_wind_speed_measurement_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_measured_value_undefine_reported( +@@ -49696,7 +49696,7 @@ bool dotdot_is_supported_wind_speed_measurement_min_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_wind_speed_measurement_min_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49707,7 +49707,7 @@ int16_t dotdot_get_wind_speed_measurement_min_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MIN_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49719,7 +49719,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_min_measured_value ++ uint16_t new_min_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49732,7 +49732,7 @@ sl_status_t dotdot_set_wind_speed_measurement_min_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_min_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_min_measured_value_undefine_reported( +@@ -49807,7 +49807,7 @@ bool dotdot_is_supported_wind_speed_measurement_max_measured_value( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_wind_speed_measurement_max_measured_value( ++uint16_t dotdot_get_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49818,7 +49818,7 @@ int16_t dotdot_get_wind_speed_measurement_max_measured_value( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_MAX_MEASURED_VALUE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49830,7 +49830,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_measured_value ++ uint16_t new_max_measured_value + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49843,7 +49843,7 @@ sl_status_t dotdot_set_wind_speed_measurement_max_measured_value( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_measured_value, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_max_measured_value_undefine_reported( +@@ -49918,7 +49918,7 @@ bool dotdot_is_supported_wind_speed_measurement_tolerance( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_wind_speed_measurement_tolerance( ++uint16_t dotdot_get_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -49929,7 +49929,7 @@ int16_t dotdot_get_wind_speed_measurement_tolerance( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_WIND_SPEED_MEASUREMENT_TOLERANCE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -49941,7 +49941,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_tolerance ++ uint16_t new_tolerance + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -49954,7 +49954,7 @@ sl_status_t dotdot_set_wind_speed_measurement_tolerance( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_tolerance, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_wind_speed_measurement_tolerance_undefine_reported( +@@ -51929,7 +51929,7 @@ bool dotdot_is_supported_ias_zone_zoneid( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ias_zone_zoneid( ++uint8_t dotdot_get_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -51940,7 +51940,7 @@ int8_t dotdot_get_ias_zone_zoneid( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_ZONEID); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -51952,7 +51952,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_zoneid ++ uint8_t new_zoneid + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -51965,7 +51965,7 @@ sl_status_t dotdot_set_ias_zone_zoneid( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_zoneid, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ias_zone_zoneid_undefine_reported( +@@ -52040,7 +52040,7 @@ bool dotdot_is_supported_ias_zone_number_of_zone_sensitivity_levels_supported( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( ++uint8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52051,7 +52051,7 @@ int8_t dotdot_get_ias_zone_number_of_zone_sensitivity_levels_supported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_NUMBER_OF_ZONE_SENSITIVITY_LEVELS_SUPPORTED); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52063,7 +52063,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_number_of_zone_sensitivity_levels_supported ++ uint8_t new_number_of_zone_sensitivity_levels_supported + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52076,7 +52076,7 @@ sl_status_t dotdot_set_ias_zone_number_of_zone_sensitivity_levels_supported( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_zone_sensitivity_levels_supported, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ias_zone_number_of_zone_sensitivity_levels_supported_undefine_reported( +@@ -52151,7 +52151,7 @@ bool dotdot_is_supported_ias_zone_current_zone_sensitivity_level( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_ias_zone_current_zone_sensitivity_level( ++uint8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52162,7 +52162,7 @@ int8_t dotdot_get_ias_zone_current_zone_sensitivity_level( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IAS_ZONE_CURRENT_ZONE_SENSITIVITY_LEVEL); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52174,7 +52174,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_current_zone_sensitivity_level ++ uint8_t new_current_zone_sensitivity_level + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52187,7 +52187,7 @@ sl_status_t dotdot_set_ias_zone_current_zone_sensitivity_level( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_zone_sensitivity_level, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_ias_zone_current_zone_sensitivity_level_undefine_reported( +@@ -52308,7 +52308,7 @@ bool dotdot_is_supported_iaswd_max_duration( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_iaswd_max_duration( ++uint16_t dotdot_get_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52319,7 +52319,7 @@ int16_t dotdot_get_iaswd_max_duration( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_IASWD_MAX_DURATION); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52331,7 +52331,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_max_duration ++ uint16_t new_max_duration + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52344,7 +52344,7 @@ sl_status_t dotdot_set_iaswd_max_duration( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_max_duration, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_iaswd_max_duration_undefine_reported( +@@ -52444,7 +52444,7 @@ bool dotdot_is_supported_metering_current_summation_delivered( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_metering_current_summation_delivered( ++uint64_t dotdot_get_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52455,7 +52455,7 @@ int64_t dotdot_get_metering_current_summation_delivered( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_DELIVERED); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52467,7 +52467,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_summation_delivered ++ uint64_t new_current_summation_delivered + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52480,7 +52480,7 @@ sl_status_t dotdot_set_metering_current_summation_delivered( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_summation_delivered, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_metering_current_summation_delivered_undefine_reported( +@@ -52555,7 +52555,7 @@ bool dotdot_is_supported_metering_current_summation_received( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_metering_current_summation_received( ++uint64_t dotdot_get_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52566,7 +52566,7 @@ int64_t dotdot_get_metering_current_summation_received( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_SUMMATION_RECEIVED); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52578,7 +52578,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_summation_received ++ uint64_t new_current_summation_received + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52591,7 +52591,7 @@ sl_status_t dotdot_set_metering_current_summation_received( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_summation_received, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_metering_current_summation_received_undefine_reported( +@@ -52666,7 +52666,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_metering_current_max_demand_delivered( ++uint64_t dotdot_get_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -52677,7 +52677,7 @@ int64_t dotdot_get_metering_current_max_demand_delivered( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -52689,7 +52689,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_max_demand_delivered ++ uint64_t new_current_max_demand_delivered + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -52702,7 +52702,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_delivered, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_metering_current_max_demand_delivered_undefine_reported( +@@ -52999,7 +52999,7 @@ bool dotdot_is_supported_metering_reading_snap_shot_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_metering_reading_snap_shot_time( ++uint32_t dotdot_get_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53010,7 +53010,7 @@ uint8_t dotdot_get_metering_reading_snap_shot_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_READING_SNAP_SHOT_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53022,7 +53022,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_reading_snap_shot_time ++ uint32_t new_reading_snap_shot_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53035,7 +53035,7 @@ sl_status_t dotdot_set_metering_reading_snap_shot_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_reading_snap_shot_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_metering_reading_snap_shot_time_undefine_reported( +@@ -53110,7 +53110,7 @@ bool dotdot_is_supported_metering_current_max_demand_delivered_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_metering_current_max_demand_delivered_time( ++uint32_t dotdot_get_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53121,7 +53121,7 @@ uint8_t dotdot_get_metering_current_max_demand_delivered_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_DELIVERED_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53133,7 +53133,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_max_demand_delivered_time ++ uint32_t new_current_max_demand_delivered_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53146,7 +53146,7 @@ sl_status_t dotdot_set_metering_current_max_demand_delivered_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_delivered_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_metering_current_max_demand_delivered_time_undefine_reported( +@@ -53221,7 +53221,7 @@ bool dotdot_is_supported_metering_current_max_demand_received_time( + return attribute_store_node_exists(node); + } + +-uint8_t dotdot_get_metering_current_max_demand_received_time( ++uint32_t dotdot_get_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53232,7 +53232,7 @@ uint8_t dotdot_get_metering_current_max_demand_received_time( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_MAX_DEMAND_RECEIVED_TIME); + +- uint8_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53244,7 +53244,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- uint8_t new_current_max_demand_received_time ++ uint32_t new_current_max_demand_received_time + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53257,7 +53257,7 @@ sl_status_t dotdot_set_metering_current_max_demand_received_time( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_max_demand_received_time, +- sizeof(uint8_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_metering_current_max_demand_received_time_undefine_reported( +@@ -53332,7 +53332,7 @@ bool dotdot_is_supported_metering_default_update_period( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_metering_default_update_period( ++uint8_t dotdot_get_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53343,7 +53343,7 @@ int8_t dotdot_get_metering_default_update_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_DEFAULT_UPDATE_PERIOD); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53355,7 +53355,7 @@ sl_status_t dotdot_set_metering_default_update_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_default_update_period ++ uint8_t new_default_update_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53368,7 +53368,7 @@ sl_status_t dotdot_set_metering_default_update_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_default_update_period, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_metering_default_update_period_undefine_reported( +@@ -53554,7 +53554,7 @@ bool dotdot_is_supported_metering_current_inlet_energy_carrier_summation( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_metering_current_inlet_energy_carrier_summation( ++uint64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53565,7 +53565,7 @@ int64_t dotdot_get_metering_current_inlet_energy_carrier_summation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_INLET_ENERGY_CARRIER_SUMMATION); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53577,7 +53577,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_inlet_energy_carrier_summation ++ uint64_t new_current_inlet_energy_carrier_summation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53590,7 +53590,7 @@ sl_status_t dotdot_set_metering_current_inlet_energy_carrier_summation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_inlet_energy_carrier_summation, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_metering_current_inlet_energy_carrier_summation_undefine_reported( +@@ -53665,7 +53665,7 @@ bool dotdot_is_supported_metering_current_outlet_energy_carrier_summation( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_metering_current_outlet_energy_carrier_summation( ++uint64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -53676,7 +53676,7 @@ int64_t dotdot_get_metering_current_outlet_energy_carrier_summation( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_CURRENT_OUTLET_ENERGY_CARRIER_SUMMATION); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -53688,7 +53688,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_current_outlet_energy_carrier_summation ++ uint64_t new_current_outlet_energy_carrier_summation + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -53701,7 +53701,7 @@ sl_status_t dotdot_set_metering_current_outlet_energy_carrier_summation( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_current_outlet_energy_carrier_summation, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_metering_current_outlet_energy_carrier_summation_undefine_reported( +@@ -54109,7 +54109,7 @@ bool dotdot_is_supported_metering_multiplier( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_metering_multiplier( ++uint32_t dotdot_get_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -54120,7 +54120,7 @@ int32_t dotdot_get_metering_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_MULTIPLIER); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -54132,7 +54132,7 @@ sl_status_t dotdot_set_metering_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_multiplier ++ uint32_t new_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -54145,7 +54145,7 @@ sl_status_t dotdot_set_metering_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_multiplier, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_metering_multiplier_undefine_reported( +@@ -54220,7 +54220,7 @@ bool dotdot_is_supported_metering_divisor( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_metering_divisor( ++uint32_t dotdot_get_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -54231,7 +54231,7 @@ int32_t dotdot_get_metering_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_METERING_DIVISOR); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -54243,7 +54243,7 @@ sl_status_t dotdot_set_metering_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_divisor ++ uint32_t new_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -54256,7 +54256,7 @@ sl_status_t dotdot_set_metering_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_divisor, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_metering_divisor_undefine_reported( +@@ -56537,7 +56537,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56548,7 +56548,7 @@ int16_t dotdot_get_electrical_measurement_dc_voltage_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56560,7 +56560,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_voltage_multiplier ++ uint16_t new_dc_voltage_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56573,7 +56573,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_voltage_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_voltage_multiplier_undefine_reported( +@@ -56648,7 +56648,7 @@ bool dotdot_is_supported_electrical_measurement_dc_voltage_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_voltage_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56659,7 +56659,7 @@ int16_t dotdot_get_electrical_measurement_dc_voltage_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_VOLTAGE_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56671,7 +56671,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_voltage_divisor ++ uint16_t new_dc_voltage_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56684,7 +56684,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_voltage_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_voltage_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_voltage_divisor_undefine_reported( +@@ -56759,7 +56759,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_current_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56770,7 +56770,7 @@ int16_t dotdot_get_electrical_measurement_dc_current_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56782,7 +56782,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_current_multiplier ++ uint16_t new_dc_current_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56795,7 +56795,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_current_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_current_multiplier_undefine_reported( +@@ -56870,7 +56870,7 @@ bool dotdot_is_supported_electrical_measurement_dc_current_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_current_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56881,7 +56881,7 @@ int16_t dotdot_get_electrical_measurement_dc_current_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_CURRENT_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -56893,7 +56893,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_current_divisor ++ uint16_t new_dc_current_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -56906,7 +56906,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_current_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_current_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_current_divisor_undefine_reported( +@@ -56981,7 +56981,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_power_multiplier( ++uint16_t dotdot_get_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -56992,7 +56992,7 @@ int16_t dotdot_get_electrical_measurement_dc_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57004,7 +57004,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_power_multiplier ++ uint16_t new_dc_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57017,7 +57017,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_power_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_power_multiplier_undefine_reported( +@@ -57092,7 +57092,7 @@ bool dotdot_is_supported_electrical_measurement_dc_power_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_dc_power_divisor( ++uint16_t dotdot_get_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57103,7 +57103,7 @@ int16_t dotdot_get_electrical_measurement_dc_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_DC_POWER_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57115,7 +57115,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_dc_power_divisor ++ uint16_t new_dc_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57128,7 +57128,7 @@ sl_status_t dotdot_set_electrical_measurement_dc_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dc_power_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_dc_power_divisor_undefine_reported( +@@ -57203,7 +57203,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_frequency( ++uint16_t dotdot_get_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57214,7 +57214,7 @@ int16_t dotdot_get_electrical_measurement_ac_frequency( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57226,7 +57226,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency ++ uint16_t new_ac_frequency + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57239,7 +57239,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_undefine_reported( +@@ -57314,7 +57314,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_min( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_frequency_min( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57325,7 +57325,7 @@ int16_t dotdot_get_electrical_measurement_ac_frequency_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MIN); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57337,7 +57337,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_min ++ uint16_t new_ac_frequency_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57350,7 +57350,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_min, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_min_undefine_reported( +@@ -57425,7 +57425,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_max( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_frequency_max( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57436,7 +57436,7 @@ int16_t dotdot_get_electrical_measurement_ac_frequency_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MAX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57448,7 +57448,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_max ++ uint16_t new_ac_frequency_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57461,7 +57461,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_max, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_max_undefine_reported( +@@ -57536,7 +57536,7 @@ bool dotdot_is_supported_electrical_measurement_neutral_current( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_neutral_current( ++uint16_t dotdot_get_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57547,7 +57547,7 @@ int16_t dotdot_get_electrical_measurement_neutral_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_NEUTRAL_CURRENT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57559,7 +57559,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neutral_current ++ uint16_t new_neutral_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57572,7 +57572,7 @@ sl_status_t dotdot_set_electrical_measurement_neutral_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neutral_current, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_neutral_current_undefine_reported( +@@ -57869,7 +57869,7 @@ bool dotdot_is_supported_electrical_measurement_total_apparent_power( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_electrical_measurement_total_apparent_power( ++uint32_t dotdot_get_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -57880,7 +57880,7 @@ int32_t dotdot_get_electrical_measurement_total_apparent_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_TOTAL_APPARENT_POWER); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -57892,7 +57892,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_total_apparent_power ++ uint32_t new_total_apparent_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -57905,7 +57905,7 @@ sl_status_t dotdot_set_electrical_measurement_total_apparent_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_total_apparent_power, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_electrical_measurement_total_apparent_power_undefine_reported( +@@ -59312,7 +59312,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59323,7 +59323,7 @@ int16_t dotdot_get_electrical_measurement_ac_frequency_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59335,7 +59335,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_multiplier ++ uint16_t new_ac_frequency_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59348,7 +59348,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_multiplier_undefine_reported( +@@ -59423,7 +59423,7 @@ bool dotdot_is_supported_electrical_measurement_ac_frequency_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_frequency_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59434,7 +59434,7 @@ int16_t dotdot_get_electrical_measurement_ac_frequency_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_FREQUENCY_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59446,7 +59446,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_frequency_divisor ++ uint16_t new_ac_frequency_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59459,7 +59459,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_frequency_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_frequency_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_frequency_divisor_undefine_reported( +@@ -59534,7 +59534,7 @@ bool dotdot_is_supported_electrical_measurement_power_multiplier( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_electrical_measurement_power_multiplier( ++uint32_t dotdot_get_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59545,7 +59545,7 @@ int32_t dotdot_get_electrical_measurement_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_MULTIPLIER); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59557,7 +59557,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power_multiplier ++ uint32_t new_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59570,7 +59570,7 @@ sl_status_t dotdot_set_electrical_measurement_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_multiplier, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_electrical_measurement_power_multiplier_undefine_reported( +@@ -59645,7 +59645,7 @@ bool dotdot_is_supported_electrical_measurement_power_divisor( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_electrical_measurement_power_divisor( ++uint32_t dotdot_get_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59656,7 +59656,7 @@ int32_t dotdot_get_electrical_measurement_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_POWER_DIVISOR); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -59668,7 +59668,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_power_divisor ++ uint32_t new_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -59681,7 +59681,7 @@ sl_status_t dotdot_set_electrical_measurement_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_power_divisor, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_electrical_measurement_power_divisor_undefine_reported( +@@ -59978,7 +59978,7 @@ bool dotdot_is_supported_electrical_measurement_line_current( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_line_current( ++uint16_t dotdot_get_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -59989,7 +59989,7 @@ int16_t dotdot_get_electrical_measurement_line_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60001,7 +60001,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current ++ uint16_t new_line_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60014,7 +60014,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_undefine_reported( +@@ -60311,7 +60311,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage( ++uint16_t dotdot_get_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60322,7 +60322,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60334,7 +60334,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage ++ uint16_t new_rms_voltage + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60347,7 +60347,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_undefine_reported( +@@ -60422,7 +60422,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_min( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60433,7 +60433,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60445,7 +60445,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min ++ uint16_t new_rms_voltage_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60458,7 +60458,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_undefine_reported( +@@ -60533,7 +60533,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_max( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60544,7 +60544,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60556,7 +60556,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max ++ uint16_t new_rms_voltage_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60569,7 +60569,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_undefine_reported( +@@ -60644,7 +60644,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current( ++uint16_t dotdot_get_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60655,7 +60655,7 @@ int16_t dotdot_get_electrical_measurement_rms_current( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60667,7 +60667,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current ++ uint16_t new_rms_current + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60680,7 +60680,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_undefine_reported( +@@ -60755,7 +60755,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_min( ++uint16_t dotdot_get_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60766,7 +60766,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_min( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60778,7 +60778,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min ++ uint16_t new_rms_current_min + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60791,7 +60791,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_undefine_reported( +@@ -60866,7 +60866,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_max( ++uint16_t dotdot_get_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -60877,7 +60877,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_max( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -60889,7 +60889,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max ++ uint16_t new_rms_current_max + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -60902,7 +60902,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_undefine_reported( +@@ -61421,7 +61421,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_apparent_power( ++uint16_t dotdot_get_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61432,7 +61432,7 @@ int16_t dotdot_get_electrical_measurement_apparent_power( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61444,7 +61444,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power ++ uint16_t new_apparent_power + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61457,7 +61457,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_undefine_reported( +@@ -61643,7 +61643,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61654,7 +61654,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61666,7 +61666,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period ++ uint16_t new_average_rms_voltage_measurement_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61679,7 +61679,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_undefine_reported( +@@ -61754,7 +61754,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61765,7 +61765,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61777,7 +61777,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter ++ uint16_t new_average_rms_over_voltage_counter + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61790,7 +61790,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_undefine_reported( +@@ -61865,7 +61865,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61876,7 +61876,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61888,7 +61888,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter ++ uint16_t new_average_rms_under_voltage_counter + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -61901,7 +61901,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_undefine_reported( +@@ -61976,7 +61976,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -61987,7 +61987,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -61999,7 +61999,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period ++ uint16_t new_rms_extreme_over_voltage_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62012,7 +62012,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_undefine_reported( +@@ -62087,7 +62087,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62098,7 +62098,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62110,7 +62110,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period ++ uint16_t new_rms_extreme_under_voltage_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62123,7 +62123,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_undefine_reported( +@@ -62198,7 +62198,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62209,7 +62209,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62221,7 +62221,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period ++ uint16_t new_rms_voltage_sag_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62234,7 +62234,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_undefine_reported( +@@ -62309,7 +62309,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62320,7 +62320,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62332,7 +62332,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period ++ uint16_t new_rms_voltage_swell_period + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62345,7 +62345,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_undefine_reported( +@@ -62420,7 +62420,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62431,7 +62431,7 @@ int16_t dotdot_get_electrical_measurement_ac_voltage_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62443,7 +62443,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_voltage_multiplier ++ uint16_t new_ac_voltage_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62456,7 +62456,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_voltage_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_voltage_multiplier_undefine_reported( +@@ -62531,7 +62531,7 @@ bool dotdot_is_supported_electrical_measurement_ac_voltage_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_voltage_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62542,7 +62542,7 @@ int16_t dotdot_get_electrical_measurement_ac_voltage_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_VOLTAGE_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62554,7 +62554,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_voltage_divisor ++ uint16_t new_ac_voltage_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62567,7 +62567,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_voltage_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_voltage_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_voltage_divisor_undefine_reported( +@@ -62642,7 +62642,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_current_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62653,7 +62653,7 @@ int16_t dotdot_get_electrical_measurement_ac_current_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62665,7 +62665,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_current_multiplier ++ uint16_t new_ac_current_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62678,7 +62678,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_current_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_current_multiplier_undefine_reported( +@@ -62753,7 +62753,7 @@ bool dotdot_is_supported_electrical_measurement_ac_current_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_current_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62764,7 +62764,7 @@ int16_t dotdot_get_electrical_measurement_ac_current_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_CURRENT_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62776,7 +62776,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_current_divisor ++ uint16_t new_ac_current_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62789,7 +62789,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_current_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_current_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_current_divisor_undefine_reported( +@@ -62864,7 +62864,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_multiplier( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_power_multiplier( ++uint16_t dotdot_get_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62875,7 +62875,7 @@ int16_t dotdot_get_electrical_measurement_ac_power_multiplier( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_MULTIPLIER); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62887,7 +62887,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_power_multiplier ++ uint16_t new_ac_power_multiplier + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -62900,7 +62900,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_multiplier( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_power_multiplier, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_power_multiplier_undefine_reported( +@@ -62975,7 +62975,7 @@ bool dotdot_is_supported_electrical_measurement_ac_power_divisor( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_ac_power_divisor( ++uint16_t dotdot_get_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -62986,7 +62986,7 @@ int16_t dotdot_get_electrical_measurement_ac_power_divisor( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AC_POWER_DIVISOR); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -62998,7 +62998,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_ac_power_divisor ++ uint16_t new_ac_power_divisor + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -63011,7 +63011,7 @@ sl_status_t dotdot_set_electrical_measurement_ac_power_divisor( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_ac_power_divisor, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_ac_power_divisor_undefine_reported( +@@ -64640,7 +64640,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_line_current_phb( ++uint16_t dotdot_get_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -64651,7 +64651,7 @@ int16_t dotdot_get_electrical_measurement_line_current_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -64663,7 +64663,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current_phb ++ uint16_t new_line_current_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -64676,7 +64676,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_phb_undefine_reported( +@@ -64973,7 +64973,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -64984,7 +64984,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -64996,7 +64996,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_phb ++ uint16_t new_rms_voltage_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65009,7 +65009,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_phb_undefine_reported( +@@ -65084,7 +65084,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65095,7 +65095,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_min_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65107,7 +65107,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min_phb ++ uint16_t new_rms_voltage_min_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65120,7 +65120,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_phb_undefine_reported( +@@ -65195,7 +65195,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65206,7 +65206,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_max_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65218,7 +65218,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max_phb ++ uint16_t new_rms_voltage_max_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65231,7 +65231,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_phb_undefine_reported( +@@ -65306,7 +65306,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65317,7 +65317,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65329,7 +65329,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_phb ++ uint16_t new_rms_current_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65342,7 +65342,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_phb_undefine_reported( +@@ -65417,7 +65417,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_min_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65428,7 +65428,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_min_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65440,7 +65440,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min_phb ++ uint16_t new_rms_current_min_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65453,7 +65453,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_phb_undefine_reported( +@@ -65528,7 +65528,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_max_phb( ++uint16_t dotdot_get_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -65539,7 +65539,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_max_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -65551,7 +65551,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max_phb ++ uint16_t new_rms_current_max_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -65564,7 +65564,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_phb_undefine_reported( +@@ -66083,7 +66083,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_apparent_power_phb( ++uint16_t dotdot_get_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66094,7 +66094,7 @@ int16_t dotdot_get_electrical_measurement_apparent_power_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66106,7 +66106,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power_phb ++ uint16_t new_apparent_power_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66119,7 +66119,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_phb_undefine_reported( +@@ -66305,7 +66305,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66316,7 +66316,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66328,7 +66328,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period_phb ++ uint16_t new_average_rms_voltage_measurement_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66341,7 +66341,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_phb_undefine_reported( +@@ -66416,7 +66416,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66427,7 +66427,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66439,7 +66439,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter_phb ++ uint16_t new_average_rms_over_voltage_counter_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66452,7 +66452,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_phb_undefine_reported( +@@ -66527,7 +66527,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66538,7 +66538,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66550,7 +66550,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter_phb ++ uint16_t new_average_rms_under_voltage_counter_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66563,7 +66563,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_phb_undefine_reported( +@@ -66638,7 +66638,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66649,7 +66649,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66661,7 +66661,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period_phb ++ uint16_t new_rms_extreme_over_voltage_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66674,7 +66674,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_phb_undefine_reported( +@@ -66749,7 +66749,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66760,7 +66760,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66772,7 +66772,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period_phb ++ uint16_t new_rms_extreme_under_voltage_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66785,7 +66785,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_phb_undefine_reported( +@@ -66860,7 +66860,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66871,7 +66871,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66883,7 +66883,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period_phb ++ uint16_t new_rms_voltage_sag_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -66896,7 +66896,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_phb_undefine_reported( +@@ -66971,7 +66971,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phb( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -66982,7 +66982,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phb( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHB); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -66994,7 +66994,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period_phb ++ uint16_t new_rms_voltage_swell_period_phb + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67007,7 +67007,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phb( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period_phb, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_phb_undefine_reported( +@@ -67082,7 +67082,7 @@ bool dotdot_is_supported_electrical_measurement_line_current_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_line_current_phc( ++uint16_t dotdot_get_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67093,7 +67093,7 @@ int16_t dotdot_get_electrical_measurement_line_current_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_LINE_CURRENT_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67105,7 +67105,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_line_current_phc ++ uint16_t new_line_current_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67118,7 +67118,7 @@ sl_status_t dotdot_set_electrical_measurement_line_current_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_line_current_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_line_current_phc_undefine_reported( +@@ -67415,7 +67415,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67426,7 +67426,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67438,7 +67438,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_phc ++ uint16_t new_rms_voltage_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67451,7 +67451,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_phc_undefine_reported( +@@ -67526,7 +67526,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_min_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67537,7 +67537,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_min_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MIN_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67549,7 +67549,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_min_phc ++ uint16_t new_rms_voltage_min_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67562,7 +67562,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_min_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_min_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_min_phc_undefine_reported( +@@ -67637,7 +67637,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_max_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67648,7 +67648,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_max_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_MAX_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67660,7 +67660,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_max_phc ++ uint16_t new_rms_voltage_max_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67673,7 +67673,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_max_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_max_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_max_phc_undefine_reported( +@@ -67748,7 +67748,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67759,7 +67759,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67771,7 +67771,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_phc ++ uint16_t new_rms_current_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67784,7 +67784,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_phc_undefine_reported( +@@ -67859,7 +67859,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_min_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_min_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67870,7 +67870,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_min_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MIN_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67882,7 +67882,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_min_phc ++ uint16_t new_rms_current_min_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -67895,7 +67895,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_min_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_min_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_min_phc_undefine_reported( +@@ -67970,7 +67970,7 @@ bool dotdot_is_supported_electrical_measurement_rms_current_max_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_current_max_phc( ++uint16_t dotdot_get_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -67981,7 +67981,7 @@ int16_t dotdot_get_electrical_measurement_rms_current_max_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_CURRENT_MAX_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -67993,7 +67993,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_current_max_phc ++ uint16_t new_rms_current_max_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68006,7 +68006,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_current_max_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_current_max_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_current_max_phc_undefine_reported( +@@ -68525,7 +68525,7 @@ bool dotdot_is_supported_electrical_measurement_apparent_power_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_apparent_power_phc( ++uint16_t dotdot_get_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68536,7 +68536,7 @@ int16_t dotdot_get_electrical_measurement_apparent_power_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_APPARENT_POWER_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68548,7 +68548,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apparent_power_phc ++ uint16_t new_apparent_power_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68561,7 +68561,7 @@ sl_status_t dotdot_set_electrical_measurement_apparent_power_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apparent_power_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_apparent_power_phc_undefine_reported( +@@ -68747,7 +68747,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_voltage_measurement_ + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68758,7 +68758,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_voltage_measurement_period + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68770,7 +68770,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_voltage_measurement_period_phc ++ uint16_t new_average_rms_voltage_measurement_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68783,7 +68783,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_voltage_measurement_pe + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_voltage_measurement_period_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_voltage_measurement_period_phc_undefine_reported( +@@ -68858,7 +68858,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_over_voltage_counter + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68869,7 +68869,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_over_voltage_counter_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68881,7 +68881,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_over_voltage_counter_phc ++ uint16_t new_average_rms_over_voltage_counter_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -68894,7 +68894,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_over_voltage_counter_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_over_voltage_counter_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_over_voltage_counter_phc_undefine_reported( +@@ -68969,7 +68969,7 @@ bool dotdot_is_supported_electrical_measurement_average_rms_under_voltage_counte + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( ++uint16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -68980,7 +68980,7 @@ int16_t dotdot_get_electrical_measurement_average_rms_under_voltage_counter_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -68992,7 +68992,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_rms_under_voltage_counter_phc ++ uint16_t new_average_rms_under_voltage_counter_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69005,7 +69005,7 @@ sl_status_t dotdot_set_electrical_measurement_average_rms_under_voltage_counter_ + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_rms_under_voltage_counter_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_average_rms_under_voltage_counter_phc_undefine_reported( +@@ -69080,7 +69080,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_over_voltage_period_ + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69091,7 +69091,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_over_voltage_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69103,7 +69103,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_over_voltage_period_phc ++ uint16_t new_rms_extreme_over_voltage_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69116,7 +69116,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_over_voltage_period_ph + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_over_voltage_period_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_over_voltage_period_phc_undefine_reported( +@@ -69191,7 +69191,7 @@ bool dotdot_is_supported_electrical_measurement_rms_extreme_under_voltage_period + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69202,7 +69202,7 @@ int16_t dotdot_get_electrical_measurement_rms_extreme_under_voltage_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69214,7 +69214,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_extreme_under_voltage_period_phc ++ uint16_t new_rms_extreme_under_voltage_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69227,7 +69227,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_extreme_under_voltage_period_p + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_extreme_under_voltage_period_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_extreme_under_voltage_period_phc_undefine_reported( +@@ -69302,7 +69302,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_sag_period_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69313,7 +69313,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_sag_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SAG_PERIOD_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69325,7 +69325,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_sag_period_phc ++ uint16_t new_rms_voltage_sag_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69338,7 +69338,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_sag_period_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_sag_period_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_sag_period_phc_undefine_reported( +@@ -69413,7 +69413,7 @@ bool dotdot_is_supported_electrical_measurement_rms_voltage_swell_period_phc( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( ++uint16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -69424,7 +69424,7 @@ int16_t dotdot_get_electrical_measurement_rms_voltage_swell_period_phc( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_ELECTRICAL_MEASUREMENT_RMS_VOLTAGE_SWELL_PERIOD_PHC); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -69436,7 +69436,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_rms_voltage_swell_period_phc ++ uint16_t new_rms_voltage_swell_period_phc + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -69449,7 +69449,7 @@ sl_status_t dotdot_set_electrical_measurement_rms_voltage_swell_period_phc( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_rms_voltage_swell_period_phc, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_electrical_measurement_rms_voltage_swell_period_phc_undefine_reported( +@@ -70005,7 +70005,7 @@ bool dotdot_is_supported_diagnostics_number_of_resets( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_number_of_resets( ++uint16_t dotdot_get_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70016,7 +70016,7 @@ int16_t dotdot_get_diagnostics_number_of_resets( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NUMBER_OF_RESETS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70028,7 +70028,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_number_of_resets ++ uint16_t new_number_of_resets + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70041,7 +70041,7 @@ sl_status_t dotdot_set_diagnostics_number_of_resets( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_number_of_resets, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_number_of_resets_undefine_reported( +@@ -70116,7 +70116,7 @@ bool dotdot_is_supported_diagnostics_persistent_memory_writes( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_persistent_memory_writes( ++uint16_t dotdot_get_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70127,7 +70127,7 @@ int16_t dotdot_get_diagnostics_persistent_memory_writes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PERSISTENT_MEMORY_WRITES); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70139,7 +70139,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_persistent_memory_writes ++ uint16_t new_persistent_memory_writes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70152,7 +70152,7 @@ sl_status_t dotdot_set_diagnostics_persistent_memory_writes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_persistent_memory_writes, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_persistent_memory_writes_undefine_reported( +@@ -70227,7 +70227,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_bcast( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_diagnostics_mac_rx_bcast( ++uint32_t dotdot_get_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70238,7 +70238,7 @@ int32_t dotdot_get_diagnostics_mac_rx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_BCAST); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70250,7 +70250,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_rx_bcast ++ uint32_t new_mac_rx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70263,7 +70263,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_rx_bcast, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_diagnostics_mac_rx_bcast_undefine_reported( +@@ -70338,7 +70338,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_bcast( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_diagnostics_mac_tx_bcast( ++uint32_t dotdot_get_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70349,7 +70349,7 @@ int32_t dotdot_get_diagnostics_mac_tx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_BCAST); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70361,7 +70361,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_tx_bcast ++ uint32_t new_mac_tx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70374,7 +70374,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_bcast, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_bcast_undefine_reported( +@@ -70449,7 +70449,7 @@ bool dotdot_is_supported_diagnostics_mac_rx_ucast( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_diagnostics_mac_rx_ucast( ++uint32_t dotdot_get_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70460,7 +70460,7 @@ int32_t dotdot_get_diagnostics_mac_rx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_RX_UCAST); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70472,7 +70472,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_rx_ucast ++ uint32_t new_mac_rx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70485,7 +70485,7 @@ sl_status_t dotdot_set_diagnostics_mac_rx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_rx_ucast, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_diagnostics_mac_rx_ucast_undefine_reported( +@@ -70560,7 +70560,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_diagnostics_mac_tx_ucast( ++uint32_t dotdot_get_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70571,7 +70571,7 @@ int32_t dotdot_get_diagnostics_mac_tx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70583,7 +70583,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mac_tx_ucast ++ uint32_t new_mac_tx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70596,7 +70596,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_undefine_reported( +@@ -70671,7 +70671,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_retry( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_mac_tx_ucast_retry( ++uint16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70682,7 +70682,7 @@ int16_t dotdot_get_diagnostics_mac_tx_ucast_retry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_RETRY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70694,7 +70694,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mac_tx_ucast_retry ++ uint16_t new_mac_tx_ucast_retry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70707,7 +70707,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_retry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast_retry, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_retry_undefine_reported( +@@ -70782,7 +70782,7 @@ bool dotdot_is_supported_diagnostics_mac_tx_ucast_fail( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_mac_tx_ucast_fail( ++uint16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70793,7 +70793,7 @@ int16_t dotdot_get_diagnostics_mac_tx_ucast_fail( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_MAC_TX_UCAST_FAIL); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70805,7 +70805,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_mac_tx_ucast_fail ++ uint16_t new_mac_tx_ucast_fail + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70818,7 +70818,7 @@ sl_status_t dotdot_set_diagnostics_mac_tx_ucast_fail( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mac_tx_ucast_fail, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_mac_tx_ucast_fail_undefine_reported( +@@ -70893,7 +70893,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_bcast( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_rx_bcast( ++uint16_t dotdot_get_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -70904,7 +70904,7 @@ int16_t dotdot_get_diagnostics_aps_rx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_BCAST); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -70916,7 +70916,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_rx_bcast ++ uint16_t new_aps_rx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -70929,7 +70929,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_rx_bcast, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_rx_bcast_undefine_reported( +@@ -71004,7 +71004,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_bcast( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_tx_bcast( ++uint16_t dotdot_get_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71015,7 +71015,7 @@ int16_t dotdot_get_diagnostics_aps_tx_bcast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_BCAST); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71027,7 +71027,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_bcast ++ uint16_t new_aps_tx_bcast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71040,7 +71040,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_bcast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_bcast, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_bcast_undefine_reported( +@@ -71115,7 +71115,7 @@ bool dotdot_is_supported_diagnostics_aps_rx_ucast( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_rx_ucast( ++uint16_t dotdot_get_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71126,7 +71126,7 @@ int16_t dotdot_get_diagnostics_aps_rx_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_RX_UCAST); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71138,7 +71138,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_rx_ucast ++ uint16_t new_aps_rx_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71151,7 +71151,7 @@ sl_status_t dotdot_set_diagnostics_aps_rx_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_rx_ucast, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_rx_ucast_undefine_reported( +@@ -71226,7 +71226,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_success( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_tx_ucast_success( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71237,7 +71237,7 @@ int16_t dotdot_get_diagnostics_aps_tx_ucast_success( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_SUCCESS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71249,7 +71249,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_success ++ uint16_t new_aps_tx_ucast_success + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71262,7 +71262,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_success( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_success, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_success_undefine_reported( +@@ -71337,7 +71337,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_retry( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_tx_ucast_retry( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71348,7 +71348,7 @@ int16_t dotdot_get_diagnostics_aps_tx_ucast_retry( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_RETRY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71360,7 +71360,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_retry ++ uint16_t new_aps_tx_ucast_retry + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71373,7 +71373,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_retry( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_retry, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_retry_undefine_reported( +@@ -71448,7 +71448,7 @@ bool dotdot_is_supported_diagnostics_aps_tx_ucast_fail( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_tx_ucast_fail( ++uint16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71459,7 +71459,7 @@ int16_t dotdot_get_diagnostics_aps_tx_ucast_fail( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_TX_UCAST_FAIL); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71471,7 +71471,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_tx_ucast_fail ++ uint16_t new_aps_tx_ucast_fail + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71484,7 +71484,7 @@ sl_status_t dotdot_set_diagnostics_aps_tx_ucast_fail( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_tx_ucast_fail, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_tx_ucast_fail_undefine_reported( +@@ -71559,7 +71559,7 @@ bool dotdot_is_supported_diagnostics_route_disc_initiated( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_route_disc_initiated( ++uint16_t dotdot_get_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71570,7 +71570,7 @@ int16_t dotdot_get_diagnostics_route_disc_initiated( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_ROUTE_DISC_INITIATED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71582,7 +71582,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_route_disc_initiated ++ uint16_t new_route_disc_initiated + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71595,7 +71595,7 @@ sl_status_t dotdot_set_diagnostics_route_disc_initiated( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_route_disc_initiated, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_route_disc_initiated_undefine_reported( +@@ -71670,7 +71670,7 @@ bool dotdot_is_supported_diagnostics_neighbor_added( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_neighbor_added( ++uint16_t dotdot_get_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71681,7 +71681,7 @@ int16_t dotdot_get_diagnostics_neighbor_added( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_ADDED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71693,7 +71693,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_added ++ uint16_t new_neighbor_added + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71706,7 +71706,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_added( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_added, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_added_undefine_reported( +@@ -71781,7 +71781,7 @@ bool dotdot_is_supported_diagnostics_neighbor_removed( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_neighbor_removed( ++uint16_t dotdot_get_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71792,7 +71792,7 @@ int16_t dotdot_get_diagnostics_neighbor_removed( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_REMOVED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71804,7 +71804,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_removed ++ uint16_t new_neighbor_removed + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71817,7 +71817,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_removed( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_removed, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_removed_undefine_reported( +@@ -71892,7 +71892,7 @@ bool dotdot_is_supported_diagnostics_neighbor_stale( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_neighbor_stale( ++uint16_t dotdot_get_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -71903,7 +71903,7 @@ int16_t dotdot_get_diagnostics_neighbor_stale( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NEIGHBOR_STALE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -71915,7 +71915,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_neighbor_stale ++ uint16_t new_neighbor_stale + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -71928,7 +71928,7 @@ sl_status_t dotdot_set_diagnostics_neighbor_stale( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_neighbor_stale, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_neighbor_stale_undefine_reported( +@@ -72003,7 +72003,7 @@ bool dotdot_is_supported_diagnostics_join_indication( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_join_indication( ++uint16_t dotdot_get_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72014,7 +72014,7 @@ int16_t dotdot_get_diagnostics_join_indication( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_JOIN_INDICATION); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72026,7 +72026,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_join_indication ++ uint16_t new_join_indication + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72039,7 +72039,7 @@ sl_status_t dotdot_set_diagnostics_join_indication( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_join_indication, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_join_indication_undefine_reported( +@@ -72114,7 +72114,7 @@ bool dotdot_is_supported_diagnostics_child_moved( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_child_moved( ++uint16_t dotdot_get_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72125,7 +72125,7 @@ int16_t dotdot_get_diagnostics_child_moved( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_CHILD_MOVED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72137,7 +72137,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_child_moved ++ uint16_t new_child_moved + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72150,7 +72150,7 @@ sl_status_t dotdot_set_diagnostics_child_moved( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_child_moved, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_child_moved_undefine_reported( +@@ -72225,7 +72225,7 @@ bool dotdot_is_supported_diagnostics_nwkfc_failure( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_nwkfc_failure( ++uint16_t dotdot_get_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72236,7 +72236,7 @@ int16_t dotdot_get_diagnostics_nwkfc_failure( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWKFC_FAILURE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72248,7 +72248,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_nwkfc_failure ++ uint16_t new_nwkfc_failure + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72261,7 +72261,7 @@ sl_status_t dotdot_set_diagnostics_nwkfc_failure( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_nwkfc_failure, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_nwkfc_failure_undefine_reported( +@@ -72336,7 +72336,7 @@ bool dotdot_is_supported_diagnostics_apsfc_failure( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_apsfc_failure( ++uint16_t dotdot_get_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72347,7 +72347,7 @@ int16_t dotdot_get_diagnostics_apsfc_failure( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APSFC_FAILURE); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72359,7 +72359,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_apsfc_failure ++ uint16_t new_apsfc_failure + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72372,7 +72372,7 @@ sl_status_t dotdot_set_diagnostics_apsfc_failure( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_apsfc_failure, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_apsfc_failure_undefine_reported( +@@ -72447,7 +72447,7 @@ bool dotdot_is_supported_diagnostics_aps_unauthorized_key( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_unauthorized_key( ++uint16_t dotdot_get_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72458,7 +72458,7 @@ int16_t dotdot_get_diagnostics_aps_unauthorized_key( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_UNAUTHORIZED_KEY); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72470,7 +72470,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_unauthorized_key ++ uint16_t new_aps_unauthorized_key + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72483,7 +72483,7 @@ sl_status_t dotdot_set_diagnostics_aps_unauthorized_key( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_unauthorized_key, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_unauthorized_key_undefine_reported( +@@ -72558,7 +72558,7 @@ bool dotdot_is_supported_diagnostics_nwk_decrypt_failures( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_nwk_decrypt_failures( ++uint16_t dotdot_get_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72569,7 +72569,7 @@ int16_t dotdot_get_diagnostics_nwk_decrypt_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_NWK_DECRYPT_FAILURES); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72581,7 +72581,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_nwk_decrypt_failures ++ uint16_t new_nwk_decrypt_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72594,7 +72594,7 @@ sl_status_t dotdot_set_diagnostics_nwk_decrypt_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_nwk_decrypt_failures, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_nwk_decrypt_failures_undefine_reported( +@@ -72669,7 +72669,7 @@ bool dotdot_is_supported_diagnostics_aps_decrypt_failures( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_aps_decrypt_failures( ++uint16_t dotdot_get_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72680,7 +72680,7 @@ int16_t dotdot_get_diagnostics_aps_decrypt_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_APS_DECRYPT_FAILURES); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72692,7 +72692,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_aps_decrypt_failures ++ uint16_t new_aps_decrypt_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72705,7 +72705,7 @@ sl_status_t dotdot_set_diagnostics_aps_decrypt_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_aps_decrypt_failures, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_aps_decrypt_failures_undefine_reported( +@@ -72780,7 +72780,7 @@ bool dotdot_is_supported_diagnostics_packet_buffer_allocate_failures( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( ++uint16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72791,7 +72791,7 @@ int16_t dotdot_get_diagnostics_packet_buffer_allocate_failures( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_BUFFER_ALLOCATE_FAILURES); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72803,7 +72803,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_packet_buffer_allocate_failures ++ uint16_t new_packet_buffer_allocate_failures + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72816,7 +72816,7 @@ sl_status_t dotdot_set_diagnostics_packet_buffer_allocate_failures( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_packet_buffer_allocate_failures, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_packet_buffer_allocate_failures_undefine_reported( +@@ -72891,7 +72891,7 @@ bool dotdot_is_supported_diagnostics_relayed_ucast( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_relayed_ucast( ++uint16_t dotdot_get_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -72902,7 +72902,7 @@ int16_t dotdot_get_diagnostics_relayed_ucast( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_RELAYED_UCAST); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -72914,7 +72914,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_relayed_ucast ++ uint16_t new_relayed_ucast + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -72927,7 +72927,7 @@ sl_status_t dotdot_set_diagnostics_relayed_ucast( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_relayed_ucast, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_relayed_ucast_undefine_reported( +@@ -73002,7 +73002,7 @@ bool dotdot_is_supported_diagnostics_phy_to_mac_queue_limit_reached( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( ++uint16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73013,7 +73013,7 @@ int16_t dotdot_get_diagnostics_phy_to_mac_queue_limit_reached( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PHY_TO_MAC_QUEUE_LIMIT_REACHED); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73025,7 +73025,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_phy_to_mac_queue_limit_reached ++ uint16_t new_phy_to_mac_queue_limit_reached + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73038,7 +73038,7 @@ sl_status_t dotdot_set_diagnostics_phy_to_mac_queue_limit_reached( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_phy_to_mac_queue_limit_reached, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_phy_to_mac_queue_limit_reached_undefine_reported( +@@ -73113,7 +73113,7 @@ bool dotdot_is_supported_diagnostics_packet_validate_drop_count( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_packet_validate_drop_count( ++uint16_t dotdot_get_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73124,7 +73124,7 @@ int16_t dotdot_get_diagnostics_packet_validate_drop_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_PACKET_VALIDATE_DROP_COUNT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73136,7 +73136,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_packet_validate_drop_count ++ uint16_t new_packet_validate_drop_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73149,7 +73149,7 @@ sl_status_t dotdot_set_diagnostics_packet_validate_drop_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_packet_validate_drop_count, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_packet_validate_drop_count_undefine_reported( +@@ -73224,7 +73224,7 @@ bool dotdot_is_supported_diagnostics_average_mac_retry_per_aps_message_sent( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( ++uint16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73235,7 +73235,7 @@ int16_t dotdot_get_diagnostics_average_mac_retry_per_aps_message_sent( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_AVERAGE_MAC_RETRY_PER_APS_MESSAGE_SENT); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73247,7 +73247,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_average_mac_retry_per_aps_message_sent ++ uint16_t new_average_mac_retry_per_aps_message_sent + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73260,7 +73260,7 @@ sl_status_t dotdot_set_diagnostics_average_mac_retry_per_aps_message_sent( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_average_mac_retry_per_aps_message_sent, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_diagnostics_average_mac_retry_per_aps_message_sent_undefine_reported( +@@ -73335,7 +73335,7 @@ bool dotdot_is_supported_diagnostics_last_messagelqi( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_diagnostics_last_messagelqi( ++uint8_t dotdot_get_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73346,7 +73346,7 @@ int8_t dotdot_get_diagnostics_last_messagelqi( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_DIAGNOSTICS_LAST_MESSAGELQI); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73358,7 +73358,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_last_messagelqi ++ uint8_t new_last_messagelqi + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -73371,7 +73371,7 @@ sl_status_t dotdot_set_diagnostics_last_messagelqi( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_last_messagelqi, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_diagnostics_last_messagelqi_undefine_reported( +@@ -73925,7 +73925,7 @@ bool dotdot_is_supported_state_endpoint_id_list( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_state_endpoint_id_list( ++uint8_t dotdot_get_state_endpoint_id_list( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -73936,7 +73936,7 @@ int8_t dotdot_get_state_endpoint_id_list( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_STATE_ENDPOINT_ID_LIST); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -73949,7 +73949,7 @@ sl_status_t dotdot_set_state_endpoint_id_list( + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, + size_t new_endpoint_id_list_count, +- const int8_t* new_endpoint_id_list ++ const uint8_t* new_endpoint_id_list + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74261,7 +74261,7 @@ bool dotdot_is_supported_state_maximum_command_delay( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_state_maximum_command_delay( ++uint32_t dotdot_get_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -74272,7 +74272,7 @@ int32_t dotdot_get_state_maximum_command_delay( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_STATE_MAXIMUM_COMMAND_DELAY); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -74284,7 +74284,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_maximum_command_delay ++ uint32_t new_maximum_command_delay + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74297,7 +74297,7 @@ sl_status_t dotdot_set_state_maximum_command_delay( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_maximum_command_delay, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_state_maximum_command_delay_undefine_reported( +@@ -74887,7 +74887,7 @@ bool dotdot_is_supported_system_metrics_reporting_interval_seconds( + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_system_metrics_reporting_interval_seconds( ++uint32_t dotdot_get_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -74898,7 +74898,7 @@ int32_t dotdot_get_system_metrics_reporting_interval_seconds( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_REPORTING_INTERVAL_SECONDS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -74910,7 +74910,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_reporting_interval_seconds ++ uint32_t new_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -74923,7 +74923,7 @@ sl_status_t dotdot_set_system_metrics_reporting_interval_seconds( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_reporting_interval_seconds, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_system_metrics_reporting_interval_seconds_undefine_reported( +@@ -77025,7 +77025,7 @@ bool dotdot_is_supported_system_metrics_uptime_minutes( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_system_metrics_uptime_minutes( ++uint64_t dotdot_get_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -77036,7 +77036,7 @@ int64_t dotdot_get_system_metrics_uptime_minutes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_UPTIME_MINUTES); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -77048,7 +77048,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_uptime_minutes ++ uint64_t new_uptime_minutes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -77061,7 +77061,7 @@ sl_status_t dotdot_set_system_metrics_uptime_minutes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_uptime_minutes, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_system_metrics_uptime_minutes_undefine_reported( +@@ -77802,7 +77802,7 @@ bool dotdot_is_supported_system_metrics_system_interrupts( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_system_metrics_system_interrupts( ++uint64_t dotdot_get_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -77813,7 +77813,7 @@ int64_t dotdot_get_system_metrics_system_interrupts( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_SYSTEM_METRICS_SYSTEM_INTERRUPTS); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -77825,7 +77825,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_system_interrupts ++ uint64_t new_system_interrupts + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -77838,7 +77838,7 @@ sl_status_t dotdot_set_system_metrics_system_interrupts( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_system_interrupts, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_system_metrics_system_interrupts_undefine_reported( +@@ -78465,7 +78465,7 @@ bool dotdot_is_supported_application_monitoring_uptime_minutes( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_application_monitoring_uptime_minutes( ++uint64_t dotdot_get_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -78476,7 +78476,7 @@ int64_t dotdot_get_application_monitoring_uptime_minutes( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_UPTIME_MINUTES); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -78488,7 +78488,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_uptime_minutes ++ uint64_t new_uptime_minutes + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -78501,7 +78501,7 @@ sl_status_t dotdot_set_application_monitoring_uptime_minutes( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_uptime_minutes, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_application_monitoring_uptime_minutes_undefine_reported( +@@ -78576,7 +78576,7 @@ bool dotdot_is_supported_application_monitoring_process_id( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_application_monitoring_process_id( ++uint64_t dotdot_get_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -78587,7 +78587,7 @@ int64_t dotdot_get_application_monitoring_process_id( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_PROCESS_ID); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -78599,7 +78599,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_process_id ++ uint64_t new_process_id + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -78612,7 +78612,7 @@ sl_status_t dotdot_set_application_monitoring_process_id( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_process_id, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_application_monitoring_process_id_undefine_reported( +@@ -79133,7 +79133,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_statistics_reporting_interv + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( ++uint32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79144,7 +79144,7 @@ int32_t dotdot_get_application_monitoring_mqtt_statistics_reporting_interval_sec + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_STATISTICS_REPORTING_INTERVAL_SECONDS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79156,7 +79156,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_mqtt_statistics_reporting_interval_seconds ++ uint32_t new_mqtt_statistics_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79169,7 +79169,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_statistics_reporting_interval + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_statistics_reporting_interval_seconds, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_statistics_reporting_interval_seconds_undefine_reported( +@@ -79244,7 +79244,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_sent( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_application_monitoring_mqtt_messages_sent( ++uint64_t dotdot_get_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79255,7 +79255,7 @@ int64_t dotdot_get_application_monitoring_mqtt_messages_sent( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_SENT); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79267,7 +79267,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_messages_sent ++ uint64_t new_mqtt_messages_sent + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79280,7 +79280,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_sent( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_messages_sent, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_messages_sent_undefine_reported( +@@ -79355,7 +79355,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_messages_received( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_application_monitoring_mqtt_messages_received( ++uint64_t dotdot_get_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79366,7 +79366,7 @@ int64_t dotdot_get_application_monitoring_mqtt_messages_received( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_MESSAGES_RECEIVED); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79378,7 +79378,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_messages_received ++ uint64_t new_mqtt_messages_received + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79391,7 +79391,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_messages_received( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_messages_received, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_messages_received_undefine_reported( +@@ -79466,7 +79466,7 @@ bool dotdot_is_supported_application_monitoring_mqtt_subscription_count( + return attribute_store_node_exists(node); + } + +-int64_t dotdot_get_application_monitoring_mqtt_subscription_count( ++uint64_t dotdot_get_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79477,7 +79477,7 @@ int64_t dotdot_get_application_monitoring_mqtt_subscription_count( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_MQTT_SUBSCRIPTION_COUNT); + +- int64_t result = {}; ++ uint64_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79489,7 +79489,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int64_t new_mqtt_subscription_count ++ uint64_t new_mqtt_subscription_count + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79502,7 +79502,7 @@ sl_status_t dotdot_set_application_monitoring_mqtt_subscription_count( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_mqtt_subscription_count, +- sizeof(int64_t)); ++ sizeof(uint64_t)); + } + + sl_status_t dotdot_application_monitoring_mqtt_subscription_count_undefine_reported( +@@ -79910,7 +79910,7 @@ bool dotdot_is_supported_application_monitoring_application_statistics_reporting + return attribute_store_node_exists(node); + } + +-int32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( ++uint32_t dotdot_get_application_monitoring_application_statistics_reporting_interval_seconds( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -79921,7 +79921,7 @@ int32_t dotdot_get_application_monitoring_application_statistics_reporting_inter + endpoint_node, + DOTDOT_ATTRIBUTE_ID_APPLICATION_MONITORING_APPLICATION_STATISTICS_REPORTING_INTERVAL_SECONDS); + +- int32_t result = {}; ++ uint32_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -79933,7 +79933,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int32_t new_application_statistics_reporting_interval_seconds ++ uint32_t new_application_statistics_reporting_interval_seconds + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -79946,7 +79946,7 @@ sl_status_t dotdot_set_application_monitoring_application_statistics_reporting_i + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_application_statistics_reporting_interval_seconds, +- sizeof(int32_t)); ++ sizeof(uint32_t)); + } + + sl_status_t dotdot_application_monitoring_application_statistics_reporting_interval_seconds_undefine_reported( +@@ -81067,7 +81067,7 @@ bool dotdot_is_supported_user_credential_supported_user_unique_identifiers( + return attribute_store_node_exists(node); + } + +-int16_t dotdot_get_user_credential_supported_user_unique_identifiers( ++uint16_t dotdot_get_user_credential_supported_user_unique_identifiers( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -81078,7 +81078,7 @@ int16_t dotdot_get_user_credential_supported_user_unique_identifiers( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_USER_UNIQUE_IDENTIFIERS); + +- int16_t result = {}; ++ uint16_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -81090,7 +81090,7 @@ sl_status_t dotdot_set_user_credential_supported_user_unique_identifiers( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int16_t new_supported_user_unique_identifiers ++ uint16_t new_supported_user_unique_identifiers + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -81103,7 +81103,7 @@ sl_status_t dotdot_set_user_credential_supported_user_unique_identifiers( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_supported_user_unique_identifiers, +- sizeof(int16_t)); ++ sizeof(uint16_t)); + } + + sl_status_t dotdot_user_credential_supported_user_unique_identifiers_undefine_reported( +@@ -83886,7 +83886,7 @@ bool dotdot_is_supported_unify_humidity_control_humidifier_setpoint_precision( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -83897,7 +83897,7 @@ int8_t dotdot_get_unify_humidity_control_humidifier_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_HUMIDIFIER_SETPOINT_PRECISION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -83909,7 +83909,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_humidifier_setpoint_precision ++ uint8_t new_humidifier_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -83922,7 +83922,7 @@ sl_status_t dotdot_set_unify_humidity_control_humidifier_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_humidifier_setpoint_precision, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_unify_humidity_control_humidifier_setpoint_precision_undefine_reported( +@@ -84441,7 +84441,7 @@ bool dotdot_is_supported_unify_humidity_control_dehumidifier_setpoint_precision( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -84452,7 +84452,7 @@ int8_t dotdot_get_unify_humidity_control_dehumidifier_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_DEHUMIDIFIER_SETPOINT_PRECISION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -84464,7 +84464,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_dehumidifier_setpoint_precision ++ uint8_t new_dehumidifier_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -84477,7 +84477,7 @@ sl_status_t dotdot_set_unify_humidity_control_dehumidifier_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_dehumidifier_setpoint_precision, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_unify_humidity_control_dehumidifier_setpoint_precision_undefine_reported( +@@ -84996,7 +84996,7 @@ bool dotdot_is_supported_unify_humidity_control_auto_setpoint_precision( + return attribute_store_node_exists(node); + } + +-int8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( ++uint8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state) +@@ -85007,7 +85007,7 @@ int8_t dotdot_get_unify_humidity_control_auto_setpoint_precision( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_UNIFY_HUMIDITY_CONTROL_AUTO_SETPOINT_PRECISION); + +- int8_t result = {}; ++ uint8_t result = {}; + attribute_store_read_value(node, + value_state, + (uint8_t *)&result, +@@ -85019,7 +85019,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + const dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint_id, + attribute_store_node_value_state_t value_state, +- int8_t new_auto_setpoint_precision ++ uint8_t new_auto_setpoint_precision + ) + { + attribute_store_node_t endpoint_node = unify_dotdot_attributes_get_endpoint_node()(unid, endpoint_id); +@@ -85032,7 +85032,7 @@ sl_status_t dotdot_set_unify_humidity_control_auto_setpoint_precision( + return attribute_store_set_node_attribute_value(node, + value_state, + (uint8_t *)&new_auto_setpoint_precision, +- sizeof(int8_t)); ++ sizeof(uint8_t)); + } + + sl_status_t dotdot_unify_humidity_control_auto_setpoint_precision_undefine_reported( +diff --git a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp +index 414f77fe8a..329813ba1c 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp ++++ b/components/unify_dotdot_attribute_store/zap-generated/src/unify_dotdot_attribute_store_registration.cpp +@@ -104,8 +104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -114,7 +114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ZCLVersion, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -128,8 +128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -138,7 +138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ApplicationVersion, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -152,8 +152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -162,7 +162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic StackVersion, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -176,8 +176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -186,7 +186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic HWVersion, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -344,8 +344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // octstr // octstr // const char* ++ std::string attribute_type_string = "const char*"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -354,7 +354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Basic ProductCode, " +- "type: octstr // uint8_t"); ++ "type: octstr // const char*"); + } + + status |= attribute_store_register_type( +@@ -608,8 +608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -618,7 +618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltage, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -632,8 +632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -642,7 +642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsFrequency, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -680,8 +680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -690,7 +690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageMinThreshold, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -704,8 +704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -714,7 +714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageMaxThreshold, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -728,8 +728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -738,7 +738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration MainsVoltageDwellTripPoint, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -752,8 +752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -762,7 +762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -776,8 +776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -786,7 +786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageRemaining, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -848,8 +848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -858,7 +858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryAHrRating, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -872,8 +872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -882,7 +882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryQuantity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -896,8 +896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -906,7 +906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryRatedVoltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -944,8 +944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -954,7 +954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -968,8 +968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -978,7 +978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -992,8 +992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1002,7 +1002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1016,8 +1016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1026,7 +1026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryVoltageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1040,8 +1040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1050,7 +1050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1064,8 +1064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1074,7 +1074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1088,8 +1088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1098,7 +1098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1112,8 +1112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1122,7 +1122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration BatteryPercentageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1160,8 +1160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1170,7 +1170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2Voltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1184,8 +1184,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1194,7 +1194,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageRemaining, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1256,8 +1256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1266,7 +1266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2AHrRating, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -1280,8 +1280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1290,7 +1290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2Quantity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1304,8 +1304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1314,7 +1314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2RatedVoltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1352,8 +1352,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1362,7 +1362,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1376,8 +1376,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1386,7 +1386,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1400,8 +1400,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1410,7 +1410,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1424,8 +1424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1434,7 +1434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2VoltageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1448,8 +1448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1458,7 +1458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1472,8 +1472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1482,7 +1482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1496,8 +1496,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1506,7 +1506,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1520,8 +1520,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1530,7 +1530,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery2PercentageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1568,8 +1568,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1578,7 +1578,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3Voltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1592,8 +1592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1602,7 +1602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageRemaining, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1664,8 +1664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1674,7 +1674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3AHrRating, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -1688,8 +1688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1698,7 +1698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3Quantity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1712,8 +1712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1722,7 +1722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3RatedVoltage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1760,8 +1760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1770,7 +1770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1784,8 +1784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1794,7 +1794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1808,8 +1808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1818,7 +1818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1832,8 +1832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1842,7 +1842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3VoltageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1856,8 +1856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1866,7 +1866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageMinThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1880,8 +1880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1890,7 +1890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold1, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1904,8 +1904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1914,7 +1914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold2, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -1928,8 +1928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -1938,7 +1938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PowerConfiguration Battery3PercentageThreshold3, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2048,8 +2048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2058,7 +2058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration OverTempTotalDwell, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2144,8 +2144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2154,7 +2154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration LowTempDwellTripPoint, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -2168,8 +2168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2178,7 +2178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DeviceTemperatureConfiguration HighTempDwellTripPoint, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -2192,8 +2192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2202,7 +2202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Identify IdentifyTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2240,8 +2240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2250,7 +2250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes SceneCount, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2264,8 +2264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2274,7 +2274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes CurrentScene, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2288,8 +2288,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // SGroupId // SGroupId // uint8_t * +- std::string attribute_type_string = "uint8_t *"; ++ // SGroupId // SGroupId // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2298,7 +2298,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Scenes CurrentGroup, " +- "type: SGroupId // uint8_t *"); ++ "type: SGroupId // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2456,8 +2456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2466,7 +2466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OnOff OnTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2480,8 +2480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2490,7 +2490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OnOff OffWaitTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2528,8 +2528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2538,7 +2538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level CurrentLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2552,8 +2552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2562,7 +2562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level RemainingTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2576,8 +2576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2586,7 +2586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MinLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2600,8 +2600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2610,7 +2610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MaxLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2624,8 +2624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2634,7 +2634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level CurrentFrequency, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2648,8 +2648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2658,7 +2658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MinFrequency, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2672,8 +2672,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2682,7 +2682,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level MaxFrequency, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2720,8 +2720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2730,7 +2730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnOffTransitionTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2744,8 +2744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2754,7 +2754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2768,8 +2768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2778,7 +2778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OnTransitionTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2792,8 +2792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2802,7 +2802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level OffTransitionTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2816,8 +2816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2826,7 +2826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level DefaultMoveRate, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2840,8 +2840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2850,7 +2850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Level StartUpCurrentLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -2864,8 +2864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2874,7 +2874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Alarms AlarmCount, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -2888,8 +2888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2898,7 +2898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time Time, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -2960,8 +2960,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2970,7 +2970,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time DstStart, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -2984,8 +2984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -2994,7 +2994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time DstEnd, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3032,8 +3032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3042,7 +3042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time StandardTime, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3056,8 +3056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3066,7 +3066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time LocalTime, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3080,8 +3080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3090,7 +3090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time LastSetTime, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3104,8 +3104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3114,7 +3114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Time ValidUntilTime, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3128,8 +3128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3138,7 +3138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl CheckInInterval, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3152,8 +3152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3162,7 +3162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl LongPollInterval, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3176,8 +3176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3186,7 +3186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl ShortPollInterval, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3200,8 +3200,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3210,7 +3210,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl FastPollTimeout, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3224,8 +3224,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3234,7 +3234,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl CheckInIntervalMin, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3248,8 +3248,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3258,7 +3258,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl LongPollIntervalMin, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3272,8 +3272,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3282,7 +3282,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PollControl FastPollTimeoutMax, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3296,8 +3296,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3306,7 +3306,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration PhysicalClosedLimit, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3320,8 +3320,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3330,7 +3330,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration MotorStepSize, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3368,8 +3368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3378,7 +3378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ShadeConfiguration ClosedLimit, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3512,8 +3512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3522,7 +3522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock DoorOpenEvents, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3536,8 +3536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3546,7 +3546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock DoorClosedEvents, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3560,8 +3560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3570,7 +3570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock OpenPeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3584,8 +3584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3594,7 +3594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfLogRecordsSupported, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3608,8 +3608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3618,7 +3618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfTotalUsersSupported, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3632,8 +3632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3642,7 +3642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfPINUsersSupported, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3656,8 +3656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3666,7 +3666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfRFIDUsersSupported, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -3680,8 +3680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3690,7 +3690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfWeekDaySchedulesSupportedPerUser, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3704,8 +3704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3714,7 +3714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfYearDaySchedulesSupportedPerUser, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3728,8 +3728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3738,7 +3738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfHolidaySchedulesSupported, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3752,8 +3752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3762,7 +3762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MaxPINCodeLength, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3776,8 +3776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3786,7 +3786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MinPINCodeLength, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3800,8 +3800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3810,7 +3810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MaxRFIDCodeLength, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3824,8 +3824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3834,7 +3834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock MinRFIDCodeLength, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3872,8 +3872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3882,7 +3882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock NumberOfCredentialsSupportedPerUser, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3944,8 +3944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3954,7 +3954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock LEDSettings, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -3968,8 +3968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -3978,7 +3978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock AutoRelockTime, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -3992,8 +3992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4002,7 +4002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock SoundVolume, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -4208,8 +4208,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4218,7 +4218,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock WrongCodeEntryLimit, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -4232,8 +4232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4242,7 +4242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock UserCodeTemporaryDisableTime, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -4328,8 +4328,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4338,7 +4338,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DoorLock ExpiringUserTimeout, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4592,8 +4592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4602,7 +4602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering PhysicalClosedLimitLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4616,8 +4616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4626,7 +4626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering PhysicalClosedLimitTilt, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4640,8 +4640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4650,7 +4650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4664,8 +4664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4674,7 +4674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionTilt, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4688,8 +4688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4698,7 +4698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering NumberOfActuationsLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4712,8 +4712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4722,7 +4722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering NumberOfActuationsTilt, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4760,8 +4760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4770,7 +4770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionLiftPercentage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -4784,8 +4784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4794,7 +4794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering CurrentPositionTiltPercentage, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -4808,8 +4808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4818,7 +4818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledOpenLimitLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4832,8 +4832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4842,7 +4842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledClosedLimitLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4856,8 +4856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4866,7 +4866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledOpenLimitTilt, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4880,8 +4880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4890,7 +4890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering InstalledClosedLimitTilt, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4904,8 +4904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4914,7 +4914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering VelocityLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4928,8 +4928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4938,7 +4938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering AccelerationTimeLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -4952,8 +4952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -4962,7 +4962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering DecelerationTimeLift, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5000,8 +5000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // octstr // octstr // const char* ++ std::string attribute_type_string = "const char*"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5010,7 +5010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering IntermediateSetpointsLift, " +- "type: octstr // uint8_t"); ++ "type: octstr // const char*"); + } + + status |= attribute_store_register_type( +@@ -5024,8 +5024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // octstr // octstr // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // octstr // octstr // const char* ++ std::string attribute_type_string = "const char*"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5034,7 +5034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindowCovering IntermediateSetpointsTilt, " +- "type: octstr // uint8_t"); ++ "type: octstr // const char*"); + } + + status |= attribute_store_register_type( +@@ -5120,8 +5120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5130,7 +5130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl OpenEvents, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5144,8 +5144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5154,7 +5154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CloseEvents, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5168,8 +5168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5178,7 +5178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CommandOpenEvents, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5192,8 +5192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5202,7 +5202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl CommandCloseEvents, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5216,8 +5216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5226,7 +5226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl OpenPeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5240,8 +5240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5250,7 +5250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl ClosePeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5264,8 +5264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5274,7 +5274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BarrierControl BarrierPosition, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -5312,8 +5312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5322,7 +5322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxSpeed, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5336,8 +5336,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5346,7 +5346,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxFlow, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5456,8 +5456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5466,7 +5466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MinConstSpeed, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5480,8 +5480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5490,7 +5490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxConstSpeed, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5504,8 +5504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5514,7 +5514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MinConstFlow, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5528,8 +5528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5538,7 +5538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl MaxConstFlow, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5696,8 +5696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5706,7 +5706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl Speed, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -5720,8 +5720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5730,7 +5730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl LifetimeRunningHours, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -5744,8 +5744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5754,7 +5754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl Power, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -5768,8 +5768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -5778,7 +5778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PumpConfigurationAndControl LifetimeEnergyConsumed, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -6032,8 +6032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6042,7 +6042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat PICoolingDemand, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6056,8 +6056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6066,7 +6066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat PIHeatingDemand, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6488,8 +6488,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6498,7 +6498,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat NumberOfWeeklyTransitions, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6512,8 +6512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6522,7 +6522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat NumberOfDailyTransitions, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6560,8 +6560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6570,7 +6570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat TemperatureSetpointHoldDuration, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -6680,8 +6680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6690,7 +6690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat SetpointChangeSourceTimestamp, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -6704,8 +6704,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6714,7 +6714,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetback, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6728,8 +6728,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6738,7 +6738,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetbackMin, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6752,8 +6752,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6762,7 +6762,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat OccupiedSetbackMax, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6776,8 +6776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6786,7 +6786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetback, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6800,8 +6800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6810,7 +6810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetbackMin, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6824,8 +6824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6834,7 +6834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat UnoccupiedSetbackMax, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6848,8 +6848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6858,7 +6858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat EmergencyHeatDelta, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -6896,8 +6896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -6906,7 +6906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Thermostat ACCapacity, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7112,8 +7112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7122,7 +7122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl RelativeHumidity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7136,8 +7136,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7146,7 +7146,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationCooling, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7160,8 +7160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7170,7 +7170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl RHDehumidificationSetpoint, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7232,8 +7232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7242,7 +7242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationHysteresis, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7256,8 +7256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7266,7 +7266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL DehumidificationControl DehumidificationMaxCool, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7376,8 +7376,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7386,7 +7386,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentHue, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7400,8 +7400,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7410,7 +7410,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentSaturation, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7424,8 +7424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7434,7 +7434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl RemainingTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7448,8 +7448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7458,7 +7458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentX, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7472,8 +7472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7482,7 +7482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CurrentY, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7544,8 +7544,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7554,7 +7554,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTemperatureMireds, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7616,8 +7616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7626,7 +7626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl NumberOfPrimaries, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7640,8 +7640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7650,7 +7650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7664,8 +7664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7674,7 +7674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7688,8 +7688,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7698,7 +7698,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary1Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7712,8 +7712,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7722,7 +7722,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7736,8 +7736,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7746,7 +7746,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7760,8 +7760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7770,7 +7770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary2Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7784,8 +7784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7794,7 +7794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7808,8 +7808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7818,7 +7818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7832,8 +7832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7842,7 +7842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary3Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7856,8 +7856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7866,7 +7866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7880,8 +7880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7890,7 +7890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7904,8 +7904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7914,7 +7914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary4Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -7928,8 +7928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7938,7 +7938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7952,8 +7952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7962,7 +7962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -7976,8 +7976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -7986,7 +7986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary5Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8000,8 +8000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8010,7 +8010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6X, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8024,8 +8024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8034,7 +8034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6Y, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8048,8 +8048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8058,7 +8058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl Primary6Intensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8072,8 +8072,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8082,7 +8082,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl WhitePointX, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8096,8 +8096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8106,7 +8106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl WhitePointY, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8120,8 +8120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8130,7 +8130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRX, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8144,8 +8144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8154,7 +8154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRY, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8168,8 +8168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8178,7 +8178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointRIntensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8192,8 +8192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8202,7 +8202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGX, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8216,8 +8216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8226,7 +8226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGY, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8240,8 +8240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8250,7 +8250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointGIntensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8264,8 +8264,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8274,7 +8274,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBX, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8288,8 +8288,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8298,7 +8298,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBY, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8312,8 +8312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8322,7 +8322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorPointBIntensity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8336,8 +8336,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8346,7 +8346,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl EnhancedCurrentHue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8384,8 +8384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8394,7 +8394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopActive, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8408,8 +8408,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8418,7 +8418,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopDirection, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8432,8 +8432,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8442,7 +8442,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8456,8 +8456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8466,7 +8466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopStartEnhancedHue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8480,8 +8480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8490,7 +8490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorLoopStoredEnhancedHue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8528,8 +8528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8538,7 +8538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTempPhysicalMinMireds, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8552,8 +8552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8562,7 +8562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl ColorTempPhysicalMaxMireds, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8576,8 +8576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8586,7 +8586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl CoupleColorTempToLevelMinMireds, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8600,8 +8600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8610,7 +8610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ColorControl StartUpColorTemperatureMireds, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8624,8 +8624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8634,7 +8634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PhysicalMinLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8648,8 +8648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8658,7 +8658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PhysicalMaxLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8696,8 +8696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8706,7 +8706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration MinLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8720,8 +8720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8730,7 +8730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration MaxLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8744,8 +8744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8754,7 +8754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PowerOnLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8768,8 +8768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8778,7 +8778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration PowerOnFadeTime, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -8792,8 +8792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8802,7 +8802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration IntrinsicBallastFactor, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8816,8 +8816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8826,7 +8826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration BallastFactorAdjustment, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8840,8 +8840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8850,7 +8850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampQuantity, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -8912,8 +8912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8922,7 +8922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampRatedHours, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -8936,8 +8936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8946,7 +8946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampBurnHours, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -8984,8 +8984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -8994,7 +8994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL BallastConfiguration LampBurnHoursTripPoint, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -9008,8 +9008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9018,7 +9018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9032,8 +9032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9042,7 +9042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9056,8 +9056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9066,7 +9066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9080,8 +9080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9090,7 +9090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9176,8 +9176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9186,7 +9186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IlluminanceLevelSensing IlluminanceTargetLevel, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9272,8 +9272,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9282,7 +9282,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL TemperatureMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9368,8 +9368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9378,7 +9378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PressureMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9464,8 +9464,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9474,7 +9474,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PressureMeasurement ScaledTolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9512,8 +9512,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9522,7 +9522,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9536,8 +9536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9546,7 +9546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9560,8 +9560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9570,7 +9570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9584,8 +9584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9594,7 +9594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL FlowMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9608,8 +9608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9618,7 +9618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9632,8 +9632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9642,7 +9642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9656,8 +9656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9666,7 +9666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9680,8 +9680,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9690,7 +9690,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL RelativityHumidity Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9776,8 +9776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9786,7 +9786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIROccupiedToUnoccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9800,8 +9800,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9810,7 +9810,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIRUnoccupiedToOccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9824,8 +9824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9834,7 +9834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PIRUnoccupiedToOccupiedThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -9848,8 +9848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9858,7 +9858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicOccupiedToUnoccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9872,8 +9872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9882,7 +9882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicUnoccupiedToOccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9896,8 +9896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9906,7 +9906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing UltrasonicUnoccupiedToOccupiedThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -9920,8 +9920,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9930,7 +9930,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactOccupiedToUnoccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9944,8 +9944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9954,7 +9954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactUnoccupiedToOccupiedDelay, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -9968,8 +9968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -9978,7 +9978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL OccupancySensing PhysicalContactUnoccupiedToOccupiedThreshold, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -9992,8 +9992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10002,7 +10002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10016,8 +10016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10026,7 +10026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10040,8 +10040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10050,7 +10050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10064,8 +10064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10074,7 +10074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SoilMoisture Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10088,8 +10088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10098,7 +10098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10112,8 +10112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10122,7 +10122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10136,8 +10136,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10146,7 +10146,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10160,8 +10160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10170,7 +10170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL PhMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10184,8 +10184,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10194,7 +10194,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10208,8 +10208,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10218,7 +10218,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10232,8 +10232,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10242,7 +10242,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10256,8 +10256,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10266,7 +10266,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalConductivityMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10280,8 +10280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10290,7 +10290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10304,8 +10304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10314,7 +10314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MinMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10328,8 +10328,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10338,7 +10338,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement MaxMeasuredValue, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10352,8 +10352,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10362,7 +10362,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL WindSpeedMeasurement Tolerance, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10760,8 +10760,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10770,7 +10770,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone ZoneID, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -10784,8 +10784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10794,7 +10794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone NumberOfZoneSensitivityLevelsSupported, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -10808,8 +10808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10818,7 +10818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASZone CurrentZoneSensitivityLevel, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -10832,8 +10832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10842,7 +10842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL IASWD MaxDuration, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -10856,8 +10856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10866,7 +10866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentSummationDelivered, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -10880,8 +10880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10890,7 +10890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentSummationReceived, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -10904,8 +10904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10914,7 +10914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandDelivered, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -10976,8 +10976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -10986,7 +10986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering ReadingSnapShotTime, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -11000,8 +11000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11010,7 +11010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandDeliveredTime, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -11024,8 +11024,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // UTC // UTC // uint8_t +- std::string attribute_type_string = "uint8_t"; ++ // UTC // UTC // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11034,7 +11034,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentMaxDemandReceivedTime, " +- "type: UTC // uint8_t"); ++ "type: UTC // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -11048,8 +11048,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11058,7 +11058,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering DefaultUpdatePeriod, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -11096,8 +11096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11106,7 +11106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentInletEnergyCarrierSummation, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -11120,8 +11120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11130,7 +11130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering CurrentOutletEnergyCarrierSummation, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -11216,8 +11216,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11226,7 +11226,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering Multiplier, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -11240,8 +11240,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint24 // uint24 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint24 // uint24 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11250,7 +11250,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Metering Divisor, " +- "type: uint24 // int32_t"); ++ "type: uint24 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -11720,8 +11720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11730,7 +11730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCVoltageMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11744,8 +11744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11754,7 +11754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCVoltageDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11768,8 +11768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11778,7 +11778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCCurrentMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11792,8 +11792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11802,7 +11802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCCurrentDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11816,8 +11816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11826,7 +11826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCPowerMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11840,8 +11840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11850,7 +11850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement DCPowerDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11864,8 +11864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11874,7 +11874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequency, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11888,8 +11888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11898,7 +11898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMin, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11912,8 +11912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11922,7 +11922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMax, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -11936,8 +11936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -11946,7 +11946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement NeutralCurrent, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12008,8 +12008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12018,7 +12018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement TotalApparentPower, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -12320,8 +12320,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12330,7 +12330,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12344,8 +12344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12354,7 +12354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACFrequencyDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12368,8 +12368,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12378,7 +12378,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement PowerMultiplier, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -12392,8 +12392,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12402,7 +12402,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement PowerDivisor, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -12464,8 +12464,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12474,7 +12474,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrent, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12536,8 +12536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12546,7 +12546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltage, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12560,8 +12560,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12570,7 +12570,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMin, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12584,8 +12584,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12594,7 +12594,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMax, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12608,8 +12608,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12618,7 +12618,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrent, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12632,8 +12632,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12642,7 +12642,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMin, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12656,8 +12656,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12666,7 +12666,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMax, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12776,8 +12776,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12786,7 +12786,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPower, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12824,8 +12824,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12834,7 +12834,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12848,8 +12848,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12858,7 +12858,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounter, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12872,8 +12872,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12882,7 +12882,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounter, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12896,8 +12896,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12906,7 +12906,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12920,8 +12920,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12930,7 +12930,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12944,8 +12944,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12954,7 +12954,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12968,8 +12968,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -12978,7 +12978,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriod, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -12992,8 +12992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13002,7 +13002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACVoltageMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13016,8 +13016,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13026,7 +13026,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACVoltageDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13040,8 +13040,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13050,7 +13050,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACCurrentMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13064,8 +13064,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13074,7 +13074,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACCurrentDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13088,8 +13088,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13098,7 +13098,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACPowerMultiplier, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13112,8 +13112,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13122,7 +13122,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ACPowerDivisor, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13472,8 +13472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13482,7 +13482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrentPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13544,8 +13544,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13554,7 +13554,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltagePhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13568,8 +13568,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13578,7 +13578,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMinPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13592,8 +13592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13602,7 +13602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMaxPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13616,8 +13616,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13626,7 +13626,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13640,8 +13640,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13650,7 +13650,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMinPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13664,8 +13664,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13674,7 +13674,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMaxPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13784,8 +13784,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13794,7 +13794,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPowerPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13832,8 +13832,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13842,7 +13842,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriodPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13856,8 +13856,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13866,7 +13866,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounterPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13880,8 +13880,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13890,7 +13890,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounterPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13904,8 +13904,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13914,7 +13914,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriodPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13928,8 +13928,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13938,7 +13938,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriodPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13952,8 +13952,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13962,7 +13962,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriodPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -13976,8 +13976,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -13986,7 +13986,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriodPhB, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14000,8 +14000,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14010,7 +14010,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement LineCurrentPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14072,8 +14072,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14082,7 +14082,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltagePhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14096,8 +14096,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14106,7 +14106,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMinPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14120,8 +14120,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14130,7 +14130,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageMaxPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14144,8 +14144,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14154,7 +14154,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14168,8 +14168,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14178,7 +14178,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMinPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14192,8 +14192,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14202,7 +14202,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSCurrentMaxPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14312,8 +14312,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14322,7 +14322,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement ApparentPowerPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14360,8 +14360,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14370,7 +14370,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSVoltageMeasurementPeriodPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14384,8 +14384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14394,7 +14394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSOverVoltageCounterPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14408,8 +14408,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14418,7 +14418,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement AverageRMSUnderVoltageCounterPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14432,8 +14432,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14442,7 +14442,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeOverVoltagePeriodPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14456,8 +14456,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14466,7 +14466,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSExtremeUnderVoltagePeriodPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14480,8 +14480,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14490,7 +14490,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSagPeriodPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14504,8 +14504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14514,7 +14514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ElectricalMeasurement RMSVoltageSwellPeriodPhC, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14528,8 +14528,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14538,7 +14538,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NumberOfResets, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14552,8 +14552,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14562,7 +14562,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PersistentMemoryWrites, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14576,8 +14576,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14586,7 +14586,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacRxBcast, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -14600,8 +14600,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14610,7 +14610,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxBcast, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -14624,8 +14624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14634,7 +14634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacRxUcast, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -14648,8 +14648,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14658,7 +14658,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcast, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -14672,8 +14672,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14682,7 +14682,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcastRetry, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14696,8 +14696,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14706,7 +14706,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics MacTxUcastFail, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14720,8 +14720,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14730,7 +14730,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSRxBcast, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14744,8 +14744,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14754,7 +14754,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxBcast, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14768,8 +14768,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14778,7 +14778,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSRxUcast, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14792,8 +14792,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14802,7 +14802,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastSuccess, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14816,8 +14816,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14826,7 +14826,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastRetry, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14840,8 +14840,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14850,7 +14850,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSTxUcastFail, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14864,8 +14864,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14874,7 +14874,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics RouteDiscInitiated, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14888,8 +14888,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14898,7 +14898,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborAdded, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14912,8 +14912,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14922,7 +14922,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborRemoved, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14936,8 +14936,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14946,7 +14946,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NeighborStale, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14960,8 +14960,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14970,7 +14970,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics JoinIndication, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -14984,8 +14984,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -14994,7 +14994,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics ChildMoved, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15008,8 +15008,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15018,7 +15018,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NWKFCFailure, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15032,8 +15032,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15042,7 +15042,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSFCFailure, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15056,8 +15056,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15066,7 +15066,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSUnauthorizedKey, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15080,8 +15080,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15090,7 +15090,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics NWKDecryptFailures, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15104,8 +15104,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15114,7 +15114,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics APSDecryptFailures, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15128,8 +15128,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15138,7 +15138,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PacketBufferAllocateFailures, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15152,8 +15152,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15162,7 +15162,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics RelayedUcast, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15176,8 +15176,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15186,7 +15186,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PHYToMACQueueLimitReached, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15200,8 +15200,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15210,7 +15210,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics PacketValidateDropCount, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15224,8 +15224,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15234,7 +15234,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics AverageMACRetryPerAPSMessageSent, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -15248,8 +15248,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15258,7 +15258,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL Diagnostics LastMessageLQI, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -15344,8 +15344,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15354,7 +15354,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL State EndpointIdList, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -15416,8 +15416,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15426,7 +15426,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL State MaximumCommandDelay, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -15536,8 +15536,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -15546,7 +15546,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics ReportingIntervalSeconds, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -15992,8 +15992,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16002,7 +16002,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics UptimeMinutes, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16160,8 +16160,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16170,7 +16170,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL SystemMetrics SystemInterrupts, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16280,8 +16280,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16290,7 +16290,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring UptimeMinutes, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16304,8 +16304,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16314,7 +16314,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring ProcessId, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16424,8 +16424,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16434,7 +16434,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTStatisticsReportingIntervalSeconds, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -16448,8 +16448,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16458,7 +16458,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTMessagesSent, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16472,8 +16472,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16482,7 +16482,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTMessagesReceived, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16496,8 +16496,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint64 // uint64 // int64_t +- std::string attribute_type_string = "int64_t"; ++ // uint64 // uint64 // uint64_t ++ std::string attribute_type_string = "uint64_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16506,7 +16506,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring MQTTSubscriptionCount, " +- "type: uint64 // int64_t"); ++ "type: uint64 // uint64_t"); + } + + status |= attribute_store_register_type( +@@ -16592,8 +16592,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint32 // uint32 // int32_t +- std::string attribute_type_string = "int32_t"; ++ // uint32 // uint32 // uint32_t ++ std::string attribute_type_string = "uint32_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16602,7 +16602,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL ApplicationMonitoring ApplicationStatisticsReportingIntervalSeconds, " +- "type: uint32 // int32_t"); ++ "type: uint32 // uint32_t"); + } + + status |= attribute_store_register_type( +@@ -16808,8 +16808,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint16 // uint16 // int16_t +- std::string attribute_type_string = "int16_t"; ++ // uint16 // uint16 // uint16_t ++ std::string attribute_type_string = "uint16_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -16818,7 +16818,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UserCredential SupportedUserUniqueIdentifiers, " +- "type: uint16 // int16_t"); ++ "type: uint16 // uint16_t"); + } + + status |= attribute_store_register_type( +@@ -17384,8 +17384,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17394,7 +17394,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl HumidifierSetpointPrecision, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -17504,8 +17504,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17514,7 +17514,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl DehumidifierSetpointPrecision, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +@@ -17624,8 +17624,8 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + // clang-format on + + { +- // uint8 // uint8 // int8_t +- std::string attribute_type_string = "int8_t"; ++ // uint8 // uint8 // uint8_t ++ std::string attribute_type_string = "uint8_t"; + attribute_store_storage_type_t storage_type = UNKNOWN_STORAGE_TYPE; + + // clang-format off +@@ -17634,7 +17634,7 @@ sl_status_t unify_dotdot_attribute_store_registration_init() + if (storage_type == UNKNOWN_STORAGE_TYPE) { + sl_log_warning(LOG_TAG, + "Unkown storage type for ZCL UnifyHumidityControl AutoSetpointPrecision, " +- "type: uint8 // int8_t"); ++ "type: uint8 // uint8_t"); + } + + status |= attribute_store_register_type( +diff --git a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c +index 81266094a1..12f32c1833 100644 +--- a/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c ++++ b/components/unify_dotdot_attribute_store/zap-generated/test/unify_dotdot_attribute_store_test.c +@@ -4926,7 +4926,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_callback) { + // Dummy command parameters +- int16_t identify_time_value; ++ uint16_t identify_time_value; + memset(&identify_time_value, 0x00, sizeof(identify_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_identify_identify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4937,7 +4937,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_query_response_callback) { + // Dummy command parameters +- int16_t timeout_value; ++ uint16_t timeout_value; + memset(&timeout_value, 0x00, sizeof(timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_identify_identify_query_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -4970,7 +4970,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -4987,7 +4987,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_add_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5000,7 +5000,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_view_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_view_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5013,7 +5013,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -5039,7 +5039,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + // Dummy command parameters +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_get_group_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5052,7 +5052,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_remove_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_remove_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5065,7 +5065,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_groups_remove_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5085,7 +5085,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -5100,15 +5100,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_add_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- int8_t transition_time100ms_value; ++ uint8_t transition_time100ms_value; + memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5131,9 +5131,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5148,9 +5148,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_view_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5165,13 +5165,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5192,9 +5192,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5209,9 +5209,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5226,7 +5226,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5239,7 +5239,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5252,9 +5252,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_store_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_store_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5269,9 +5269,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_store_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5286,11 +5286,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_recall_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_recall_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5305,7 +5305,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_get_scene_membership_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5318,9 +5318,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_get_scene_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5337,13 +5337,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5364,9 +5364,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5381,9 +5381,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5398,13 +5398,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5427,13 +5427,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t mode_value; + memset(&mode_value, 0x00, sizeof(mode_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint8_t * group_identifier_to_value; ++ uint16_t group_identifier_to_value; + memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- int8_t scene_identifier_to_value; ++ uint8_t scene_identifier_to_value; + memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_copy_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5454,9 +5454,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_scenes_copy_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5494,7 +5494,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + OffWithEffectEffectIdentifier effect_identifier_value; + memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- int8_t effect_variant_value; ++ uint8_t effect_variant_value; + memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_on_off_off_with_effect_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5516,9 +5516,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t on_off_control_value; + memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- int16_t on_time_value; ++ uint16_t on_time_value; + memset(&on_time_value, 0x00, sizeof(on_time_value)); +- int16_t off_wait_time_value; ++ uint16_t off_wait_time_value; + memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_on_off_on_with_timed_off_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5533,9 +5533,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_callback) { + // Dummy command parameters +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5558,7 +5558,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5581,9 +5581,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5621,9 +5621,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { + // Dummy command parameters +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5646,7 +5646,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5669,9 +5669,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -5709,7 +5709,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { + // Dummy command parameters +- int16_t frequency_value; ++ uint16_t frequency_value; + memset(&frequency_value, 0x00, sizeof(frequency_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5722,7 +5722,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_reset_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5737,7 +5737,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5761,9 +5761,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- int32_t time_stamp_value; ++ uint32_t time_stamp_value; + memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_alarms_get_alarm_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5803,7 +5803,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + bool start_fast_polling_value; + memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- int16_t fast_poll_timeout_value; ++ uint16_t fast_poll_timeout_value; + memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_check_in_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5823,7 +5823,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { + // Dummy command parameters +- int32_t new_long_poll_interval_value; ++ uint32_t new_long_poll_interval_value; + memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5834,7 +5834,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { + // Dummy command parameters +- int16_t new_short_poll_interval_value; ++ uint16_t new_short_poll_interval_value; + memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5845,7 +5845,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_lock_door_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_lock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5867,7 +5867,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_door_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unlock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5889,7 +5889,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_toggle_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_toggle_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5911,9 +5911,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { + // Dummy command parameters +- int16_t timeout_in_seconds_value; ++ uint16_t timeout_in_seconds_value; + memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5937,7 +5937,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_callback) { + // Dummy command parameters +- int16_t log_index_value; ++ uint16_t log_index_value; + memset(&log_index_value, 0x00, sizeof(log_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_log_record_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5948,19 +5948,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { + // Dummy command parameters +- int16_t log_entryid_value; ++ uint16_t log_entryid_value; + memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- int32_t timestamp_value; ++ uint32_t timestamp_value; + memset(×tamp_value, 0x00, sizeof(timestamp_value)); + GetLogRecordResponseEventType event_type_value; + memset(&event_type_value, 0x00, sizeof(event_type_value)); + DrlkOperEventSource source_operation_event_value; + memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- int8_t event_id_or_alarm_code_value; ++ uint8_t event_id_or_alarm_code_value; + memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -5983,13 +5983,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6017,7 +6017,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6028,13 +6028,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t code_value; ++ const char* code_value; + memset(&code_value, 0x00, sizeof(code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6051,7 +6051,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6091,7 +6091,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_status_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6117,7 +6117,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_status_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6128,7 +6128,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6143,19 +6143,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6189,9 +6189,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6204,21 +6204,21 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { + // Dummy command parameters +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6243,9 +6243,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6269,13 +6269,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6303,9 +6303,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6318,15 +6318,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + // Dummy command parameters +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6345,9 +6345,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6371,11 +6371,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -6405,7 +6405,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6416,13 +6416,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { + // Dummy command parameters +- int8_t holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -6443,7 +6443,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6465,7 +6465,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_type_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -6491,7 +6491,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6502,7 +6502,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -6517,13 +6517,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6551,7 +6551,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6562,13 +6562,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6585,7 +6585,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6627,11 +6627,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + DataOperationTypeEnum operation_type_value; + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int32_t user_uniqueid_value; ++ uint32_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6660,7 +6660,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_callback) { + // Dummy command parameters +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_get_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6678,7 +6678,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_user_callback) { + // Dummy command parameters +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_clear_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6693,11 +6693,11 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); + OperatingEventNotificationOperationEventCode operation_event_code_value; + memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -6724,15 +6724,15 @@ void test_automatic_deduction_of_supported_commands() + memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); + ProgrammingEventNotificationProgramEventCode program_event_code_value; + memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -6763,9 +6763,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); + CredentialStruct credential_value; + memset(&credential_value, 0x00, sizeof(credential_value)); +- uint8_t credential_data_value; ++ const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -6826,7 +6826,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unbolt_door_callback) { + // Dummy command parameters +- uint8_t pin_code_value; ++ const char* pin_code_value; + memset(&pin_code_value, 0x00, sizeof(pin_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_door_lock_unbolt_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6858,7 +6858,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + // Dummy command parameters +- int16_t lift_value_value; ++ uint16_t lift_value_value; + memset(&lift_value_value, 0x00, sizeof(lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6869,7 +6869,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + // Dummy command parameters +- int8_t percentage_lift_value_value; ++ uint8_t percentage_lift_value_value; + memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6880,7 +6880,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + // Dummy command parameters +- int16_t tilt_value_value; ++ uint16_t tilt_value_value; + memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6891,7 +6891,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + // Dummy command parameters +- int8_t percentage_tilt_value_value; ++ uint8_t percentage_tilt_value_value; + memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6902,7 +6902,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + // Dummy command parameters +- int8_t percent_open_value; ++ uint8_t percent_open_value; + memset(&percent_open_value, 0x00, sizeof(percent_open_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -6977,17 +6977,17 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { + // Dummy command parameters +- int16_t time_of_day_value; ++ uint16_t time_of_day_value; + memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); + uint8_t relay_status_value; + memset(&relay_status_value, 0x00, sizeof(relay_status_value)); + int16_t local_temperature_value; + memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- int8_t humidity_percentage_value; ++ uint8_t humidity_percentage_value; + memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); + int16_t set_point_value; + memset(&set_point_value, 0x00, sizeof(set_point_value)); +- int16_t unread_entries_value; ++ uint16_t unread_entries_value; + memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7037,11 +7037,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_callback) { + // Dummy command parameters +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7066,7 +7066,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7089,9 +7089,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7114,9 +7114,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_saturation_callback) { + // Dummy command parameters +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7139,7 +7139,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7162,9 +7162,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7187,11 +7187,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7214,11 +7214,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_callback) { + // Dummy command parameters +- int16_t colorx_value; ++ uint16_t colorx_value; + memset(&colorx_value, 0x00, sizeof(colorx_value)); +- int16_t colory_value; ++ uint16_t colory_value; + memset(&colory_value, 0x00, sizeof(colory_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7268,7 +7268,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&stepx_value, 0x00, sizeof(stepx_value)); + int16_t stepy_value; + memset(&stepy_value, 0x00, sizeof(stepy_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7291,9 +7291,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { + // Dummy command parameters +- int16_t color_temperature_mireds_value; ++ uint16_t color_temperature_mireds_value; + memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7314,11 +7314,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { + // Dummy command parameters +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7343,7 +7343,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7366,9 +7366,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7391,11 +7391,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7424,9 +7424,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&action_value, 0x00, sizeof(action_value)); + CCColorLoopDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t time_value; ++ uint16_t time_value; + memset(&time_value, 0x00, sizeof(time_value)); +- int16_t start_hue_value; ++ uint16_t start_hue_value; + memset(&start_hue_value, 0x00, sizeof(start_hue_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7470,11 +7470,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7501,13 +7501,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -7536,7 +7536,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; + memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7553,9 +7553,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&zone_status_value, 0x00, sizeof(zone_status_value)); + uint8_t extended_status_value; + memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- int16_t delay_value; ++ uint16_t delay_value; + memset(&delay_value, 0x00, sizeof(delay_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7581,7 +7581,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + IasZoneType zone_type_value; + memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- int16_t manufacturer_code_value; ++ uint16_t manufacturer_code_value; + memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7594,9 +7594,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { + // Dummy command parameters +- int8_t test_mode_duration_value; ++ uint8_t test_mode_duration_value; + memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- int8_t current_zone_sensitivity_level_value; ++ uint8_t current_zone_sensitivity_level_value; + memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7611,9 +7611,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t siren_configuration_value; + memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- int16_t warning_duration_value; ++ uint16_t warning_duration_value; + memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- int8_t strobe_duty_cycle_value; ++ uint8_t strobe_duty_cycle_value; + memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); + IaswdLevel strobe_level_value; + memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +@@ -7643,11 +7643,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { + // Dummy command parameters +- int8_t profile_count_value; ++ uint8_t profile_count_value; + memset(&profile_count_value, 0x00, sizeof(profile_count_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t max_number_of_intervals_value; ++ uint8_t max_number_of_intervals_value; + memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7671,15 +7671,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { + // Dummy command parameters +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); + GetMeasurementProfileResponseStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t number_of_intervals_delivered_value; ++ uint8_t number_of_intervals_delivered_value; + memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint8_t attribute_id_value; ++ uint16_t attribute_id_value; + memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7700,11 +7700,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { + // Dummy command parameters +- uint8_t attributeid_value; ++ uint16_t attributeid_value; + memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); +- int8_t number_of_intervals_value; ++ uint8_t number_of_intervals_value; + memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7725,13 +7725,13 @@ void test_automatic_deduction_of_supported_commands() + memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); + bool transmission_successful_value; + memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- int16_t transmission_time_ms_value; ++ uint16_t transmission_time_ms_value; + memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); + int8_t tx_powerd_bm_value; + memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- int8_t tx_channel_value; ++ uint8_t tx_channel_value; + memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- int8_t routing_attempts_value; ++ uint8_t routing_attempts_value; + memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); + bool route_changed_value; + memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +@@ -7741,7 +7741,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); + int8_t ackrssi_value; + memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- int8_t ack_channel_value; ++ uint8_t ack_channel_value; + memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); + const char* last_route_failed_link_functionalunid_value; + memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +@@ -7844,7 +7844,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_binding_bind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7863,7 +7863,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_binding_unbind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7923,7 +7923,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { + // Dummy command parameters +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7941,7 +7941,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { + // Dummy command parameters +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + int64_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -7956,9 +7956,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { + // Dummy command parameters +- int16_t first_parameter_id_value; ++ uint16_t first_parameter_id_value; + memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- int16_t last_parameter_id_value; ++ uint16_t last_parameter_id_value; + memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -7971,7 +7971,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_add_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -7981,7 +7981,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -8006,7 +8006,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_modify_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -8016,7 +8016,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -8041,7 +8041,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8052,11 +8052,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_add_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -8075,11 +8075,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_modify_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -8098,11 +8098,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8142,7 +8142,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8153,7 +8153,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +@@ -8168,13 +8168,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8191,13 +8191,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8223,13 +8223,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t source_user_uniqueid_value; ++ uint16_t source_user_uniqueid_value; + memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); +- int16_t source_credential_slot_value; ++ uint16_t source_credential_slot_value; + memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); +- int16_t destination_user_uniqueid_value; ++ uint16_t destination_user_uniqueid_value; + memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); +- int16_t destination_credential_slot_value; ++ uint16_t destination_credential_slot_value; + memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_credential_association_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8248,7 +8248,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_FAIL, test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8333,9 +8333,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + SetpointType type_value; + memset(&type_value, 0x00, sizeof(type_value)); +- int8_t precision_value; ++ uint8_t precision_value; + memset(&precision_value, 0x00, sizeof(precision_value)); +- int8_t scale_value; ++ uint8_t scale_value; + memset(&scale_value, 0x00, sizeof(scale_value)); + int32_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -8365,7 +8365,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_callback) { + // Dummy command parameters +- int16_t identify_time_value; ++ uint16_t identify_time_value; + memset(&identify_time_value, 0x00, sizeof(identify_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_identify_identify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8376,7 +8376,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_identify_identify_query_response_callback) { + // Dummy command parameters +- int16_t timeout_value; ++ uint16_t timeout_value; + memset(&timeout_value, 0x00, sizeof(timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_identify_identify_query_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8409,7 +8409,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -8426,7 +8426,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_add_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8439,7 +8439,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_view_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_view_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8452,7 +8452,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -8478,7 +8478,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_get_group_membership_response_callback) { + // Dummy command parameters +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_get_group_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8491,7 +8491,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_remove_group_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_remove_group_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8504,7 +8504,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_groups_remove_group_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8524,7 +8524,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_groups_add_group_if_identifying_callback) { + // Dummy command parameters +- int16_t group_id_value; ++ uint16_t group_id_value; + memset(&group_id_value, 0x00, sizeof(group_id_value)); + const char* group_name_value; + memset(&group_name_value, 0x00, sizeof(group_name_value)); +@@ -8539,15 +8539,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_add_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); +- int8_t transition_time100ms_value; ++ uint8_t transition_time100ms_value; + memset(&transition_time100ms_value, 0x00, sizeof(transition_time100ms_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8570,9 +8570,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8587,9 +8587,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_view_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8604,13 +8604,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8631,9 +8631,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8648,9 +8648,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8665,7 +8665,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_all_scenes_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8678,7 +8678,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_remove_all_scenes_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8691,9 +8691,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_store_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_store_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8708,9 +8708,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_store_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8725,11 +8725,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_recall_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_recall_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8744,7 +8744,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_get_scene_membership_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_get_scene_membership_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8757,9 +8757,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int8_t capacity_value; ++ uint8_t capacity_value; + memset(&capacity_value, 0x00, sizeof(capacity_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_get_scene_membership_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8776,13 +8776,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8803,9 +8803,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_add_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8820,9 +8820,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback) { + // Dummy command parameters +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8837,13 +8837,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * groupid_value; ++ uint16_t groupid_value; + memset(&groupid_value, 0x00, sizeof(groupid_value)); +- int8_t sceneid_value; ++ uint8_t sceneid_value; + memset(&sceneid_value, 0x00, sizeof(sceneid_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * scene_name_value; ++ const char* scene_name_value; + memset(&scene_name_value, 0x00, sizeof(scene_name_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_enhanced_view_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8866,13 +8866,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t mode_value; + memset(&mode_value, 0x00, sizeof(mode_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); +- uint8_t * group_identifier_to_value; ++ uint16_t group_identifier_to_value; + memset(&group_identifier_to_value, 0x00, sizeof(group_identifier_to_value)); +- int8_t scene_identifier_to_value; ++ uint8_t scene_identifier_to_value; + memset(&scene_identifier_to_value, 0x00, sizeof(scene_identifier_to_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_copy_scene_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8893,9 +8893,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- uint8_t * group_identifier_from_value; ++ uint16_t group_identifier_from_value; + memset(&group_identifier_from_value, 0x00, sizeof(group_identifier_from_value)); +- int8_t scene_identifier_from_value; ++ uint8_t scene_identifier_from_value; + memset(&scene_identifier_from_value, 0x00, sizeof(scene_identifier_from_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_scenes_copy_scene_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8933,7 +8933,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + OffWithEffectEffectIdentifier effect_identifier_value; + memset(&effect_identifier_value, 0x00, sizeof(effect_identifier_value)); +- int8_t effect_variant_value; ++ uint8_t effect_variant_value; + memset(&effect_variant_value, 0x00, sizeof(effect_variant_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_on_off_off_with_effect_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8955,9 +8955,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t on_off_control_value; + memset(&on_off_control_value, 0x00, sizeof(on_off_control_value)); +- int16_t on_time_value; ++ uint16_t on_time_value; + memset(&on_time_value, 0x00, sizeof(on_time_value)); +- int16_t off_wait_time_value; ++ uint16_t off_wait_time_value; + memset(&off_wait_time_value, 0x00, sizeof(off_wait_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_on_off_on_with_timed_off_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -8972,9 +8972,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_callback) { + // Dummy command parameters +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -8997,7 +8997,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9020,9 +9020,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9060,9 +9060,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_level_with_on_off_callback) { + // Dummy command parameters +- int8_t level_value; ++ uint8_t level_value; + memset(&level_value, 0x00, sizeof(level_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9085,7 +9085,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9108,9 +9108,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + MoveStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -9148,7 +9148,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback) { + // Dummy command parameters +- int16_t frequency_value; ++ uint16_t frequency_value; + memset(&frequency_value, 0x00, sizeof(frequency_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_level_move_to_closest_frequency_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9161,7 +9161,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_reset_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9176,7 +9176,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_alarm_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9200,9 +9200,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t alarm_code_value; + memset(&alarm_code_value, 0x00, sizeof(alarm_code_value)); +- uint8_t cluster_identifier_value; ++ uint16_t cluster_identifier_value; + memset(&cluster_identifier_value, 0x00, sizeof(cluster_identifier_value)); +- int32_t time_stamp_value; ++ uint32_t time_stamp_value; + memset(&time_stamp_value, 0x00, sizeof(time_stamp_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_alarms_get_alarm_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9242,7 +9242,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + bool start_fast_polling_value; + memset(&start_fast_polling_value, 0x00, sizeof(start_fast_polling_value)); +- int16_t fast_poll_timeout_value; ++ uint16_t fast_poll_timeout_value; + memset(&fast_poll_timeout_value, 0x00, sizeof(fast_poll_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_check_in_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9262,7 +9262,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback) { + // Dummy command parameters +- int32_t new_long_poll_interval_value; ++ uint32_t new_long_poll_interval_value; + memset(&new_long_poll_interval_value, 0x00, sizeof(new_long_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_set_long_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9273,7 +9273,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback) { + // Dummy command parameters +- int16_t new_short_poll_interval_value; ++ uint16_t new_short_poll_interval_value; + memset(&new_short_poll_interval_value, 0x00, sizeof(new_short_poll_interval_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_poll_control_set_short_poll_interval_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9284,7 +9284,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_lock_door_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_lock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9306,7 +9306,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_door_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unlock_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9328,7 +9328,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_toggle_callback) { + // Dummy command parameters +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_toggle_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9350,9 +9350,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback) { + // Dummy command parameters +- int16_t timeout_in_seconds_value; ++ uint16_t timeout_in_seconds_value; + memset(&timeout_in_seconds_value, 0x00, sizeof(timeout_in_seconds_value)); +- uint8_t pin_or_rfid_code_value; ++ const char* pin_or_rfid_code_value; + memset(&pin_or_rfid_code_value, 0x00, sizeof(pin_or_rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unlock_with_timeout_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9376,7 +9376,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_callback) { + // Dummy command parameters +- int16_t log_index_value; ++ uint16_t log_index_value; + memset(&log_index_value, 0x00, sizeof(log_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_log_record_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9387,19 +9387,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback) { + // Dummy command parameters +- int16_t log_entryid_value; ++ uint16_t log_entryid_value; + memset(&log_entryid_value, 0x00, sizeof(log_entryid_value)); +- int32_t timestamp_value; ++ uint32_t timestamp_value; + memset(×tamp_value, 0x00, sizeof(timestamp_value)); + GetLogRecordResponseEventType event_type_value; + memset(&event_type_value, 0x00, sizeof(event_type_value)); + DrlkOperEventSource source_operation_event_value; + memset(&source_operation_event_value, 0x00, sizeof(source_operation_event_value)); +- int8_t event_id_or_alarm_code_value; ++ uint8_t event_id_or_alarm_code_value; + memset(&event_id_or_alarm_code_value, 0x00, sizeof(event_id_or_alarm_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_log_record_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9422,13 +9422,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9456,7 +9456,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9467,13 +9467,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t code_value; ++ const char* code_value; + memset(&code_value, 0x00, sizeof(code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_pin_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9490,7 +9490,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_pin_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9530,7 +9530,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_status_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -9556,7 +9556,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_status_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9567,7 +9567,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_status_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -9582,19 +9582,19 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9628,9 +9628,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9643,21 +9643,21 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback) { + // Dummy command parameters +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + uint8_t days_mask_value; + memset(&days_mask_value, 0x00, sizeof(days_mask_value)); +- int8_t start_hour_value; ++ uint8_t start_hour_value; + memset(&start_hour_value, 0x00, sizeof(start_hour_value)); +- int8_t start_minute_value; ++ uint8_t start_minute_value; + memset(&start_minute_value, 0x00, sizeof(start_minute_value)); +- int8_t end_hour_value; ++ uint8_t end_hour_value; + memset(&end_hour_value, 0x00, sizeof(end_hour_value)); +- int8_t end_minute_value; ++ uint8_t end_minute_value; + memset(&end_minute_value, 0x00, sizeof(end_minute_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_weekday_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9682,9 +9682,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_weekday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9708,13 +9708,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9742,9 +9742,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9757,15 +9757,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback) { + // Dummy command parameters +- int8_t scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_year_day_schedule_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9784,9 +9784,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback) { + // Dummy command parameters +- uint8_t * scheduleid_value; ++ uint8_t scheduleid_value; + memset(&scheduleid_value, 0x00, sizeof(scheduleid_value)); +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_year_day_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9810,11 +9810,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -9844,7 +9844,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9855,13 +9855,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_holiday_schedule_response_callback) { + // Dummy command parameters +- int8_t holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + zclStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); +- int32_t local_start_time_value; ++ uint32_t local_start_time_value; + memset(&local_start_time_value, 0x00, sizeof(local_start_time_value)); +- int32_t local_end_time_value; ++ uint32_t local_end_time_value; + memset(&local_end_time_value, 0x00, sizeof(local_end_time_value)); + DrlkOperMode operating_mode_during_holiday_value; + memset(&operating_mode_during_holiday_value, 0x00, sizeof(operating_mode_during_holiday_value)); +@@ -9882,7 +9882,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback) { + // Dummy command parameters +- uint8_t * holiday_scheduleid_value; ++ uint8_t holiday_scheduleid_value; + memset(&holiday_scheduleid_value, 0x00, sizeof(holiday_scheduleid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_holiday_schedule_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9904,7 +9904,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_user_type_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -9930,7 +9930,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_type_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9941,7 +9941,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_type_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -9956,13 +9956,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_set_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -9990,7 +9990,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10001,13 +10001,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback) { + // Dummy command parameters +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +- uint8_t rfid_code_value; ++ const char* rfid_code_value; + memset(&rfid_code_value, 0x00, sizeof(rfid_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_rfid_code_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10024,7 +10024,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback) { + // Dummy command parameters +- uint8_t * userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_rfid_code_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10066,11 +10066,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + DataOperationTypeEnum operation_type_value; + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int32_t user_uniqueid_value; ++ uint32_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -10099,7 +10099,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_get_user_callback) { + // Dummy command parameters +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_get_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10117,7 +10117,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_clear_user_callback) { + // Dummy command parameters +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_clear_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10132,11 +10132,11 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_event_source_value, 0x00, sizeof(operation_event_source_value)); + OperatingEventNotificationOperationEventCode operation_event_code_value; + memset(&operation_event_code_value, 0x00, sizeof(operation_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -10163,15 +10163,15 @@ void test_automatic_deduction_of_supported_commands() + memset(&program_event_source_value, 0x00, sizeof(program_event_source_value)); + ProgrammingEventNotificationProgramEventCode program_event_code_value; + memset(&program_event_code_value, 0x00, sizeof(program_event_code_value)); +- int16_t userid_value; ++ uint16_t userid_value; + memset(&userid_value, 0x00, sizeof(userid_value)); +- uint8_t pin_value; ++ const char* pin_value; + memset(&pin_value, 0x00, sizeof(pin_value)); + DrlkUserType user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); + DrlkUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +- int32_t local_time_value; ++ uint32_t local_time_value; + memset(&local_time_value, 0x00, sizeof(local_time_value)); + const char* data_value; + memset(&data_value, 0x00, sizeof(data_value)); +@@ -10202,9 +10202,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&operation_type_value, 0x00, sizeof(operation_type_value)); + CredentialStruct credential_value; + memset(&credential_value, 0x00, sizeof(credential_value)); +- uint8_t credential_data_value; ++ const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +- int16_t user_index_value; ++ uint16_t user_index_value; + memset(&user_index_value, 0x00, sizeof(user_index_value)); + DrlkSettableUserStatus user_status_value; + memset(&user_status_value, 0x00, sizeof(user_status_value)); +@@ -10265,7 +10265,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_door_lock_unbolt_door_callback) { + // Dummy command parameters +- uint8_t pin_code_value; ++ const char* pin_code_value; + memset(&pin_code_value, 0x00, sizeof(pin_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_door_lock_unbolt_door_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10297,7 +10297,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback) { + // Dummy command parameters +- int16_t lift_value_value; ++ uint16_t lift_value_value; + memset(&lift_value_value, 0x00, sizeof(lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_lift_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10308,7 +10308,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback) { + // Dummy command parameters +- int8_t percentage_lift_value_value; ++ uint8_t percentage_lift_value_value; + memset(&percentage_lift_value_value, 0x00, sizeof(percentage_lift_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_lift_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10319,7 +10319,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback) { + // Dummy command parameters +- int16_t tilt_value_value; ++ uint16_t tilt_value_value; + memset(&tilt_value_value, 0x00, sizeof(tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_tilt_value_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10330,7 +10330,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback) { + // Dummy command parameters +- int8_t percentage_tilt_value_value; ++ uint8_t percentage_tilt_value_value; + memset(&percentage_tilt_value_value, 0x00, sizeof(percentage_tilt_value_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_window_covering_go_to_tilt_percentage_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10341,7 +10341,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback) { + // Dummy command parameters +- int8_t percent_open_value; ++ uint8_t percent_open_value; + memset(&percent_open_value, 0x00, sizeof(percent_open_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_barrier_control_go_to_percent_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10416,17 +10416,17 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback) { + // Dummy command parameters +- int16_t time_of_day_value; ++ uint16_t time_of_day_value; + memset(&time_of_day_value, 0x00, sizeof(time_of_day_value)); + uint8_t relay_status_value; + memset(&relay_status_value, 0x00, sizeof(relay_status_value)); + int16_t local_temperature_value; + memset(&local_temperature_value, 0x00, sizeof(local_temperature_value)); +- int8_t humidity_percentage_value; ++ uint8_t humidity_percentage_value; + memset(&humidity_percentage_value, 0x00, sizeof(humidity_percentage_value)); + int16_t set_point_value; + memset(&set_point_value, 0x00, sizeof(set_point_value)); +- int16_t unread_entries_value; ++ uint16_t unread_entries_value; + memset(&unread_entries_value, 0x00, sizeof(unread_entries_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_thermostat_get_relay_status_log_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10476,11 +10476,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_callback) { + // Dummy command parameters +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10505,7 +10505,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10528,9 +10528,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10553,9 +10553,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_saturation_callback) { + // Dummy command parameters +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10578,7 +10578,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int8_t rate_value; ++ uint8_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10601,9 +10601,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int8_t step_size_value; ++ uint8_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int8_t transition_time_value; ++ uint8_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10626,11 +10626,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- int8_t hue_value; ++ uint8_t hue_value; + memset(&hue_value, 0x00, sizeof(hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10653,11 +10653,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_callback) { + // Dummy command parameters +- int16_t colorx_value; ++ uint16_t colorx_value; + memset(&colorx_value, 0x00, sizeof(colorx_value)); +- int16_t colory_value; ++ uint16_t colory_value; + memset(&colory_value, 0x00, sizeof(colory_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10707,7 +10707,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&stepx_value, 0x00, sizeof(stepx_value)); + int16_t stepy_value; + memset(&stepy_value, 0x00, sizeof(stepy_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10730,9 +10730,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_move_to_color_temperature_callback) { + // Dummy command parameters +- int16_t color_temperature_mireds_value; ++ uint16_t color_temperature_mireds_value; + memset(&color_temperature_mireds_value, 0x00, sizeof(color_temperature_mireds_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10753,11 +10753,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_callback) { + // Dummy command parameters +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); + CCDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10782,7 +10782,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10805,9 +10805,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10830,11 +10830,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_color_control_enhanced_move_to_hue_and_saturation_callback) { + // Dummy command parameters +- int16_t enhanced_hue_value; ++ uint16_t enhanced_hue_value; + memset(&enhanced_hue_value, 0x00, sizeof(enhanced_hue_value)); +- int8_t saturation_value; ++ uint8_t saturation_value; + memset(&saturation_value, 0x00, sizeof(saturation_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10863,9 +10863,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&action_value, 0x00, sizeof(action_value)); + CCColorLoopDirection direction_value; + memset(&direction_value, 0x00, sizeof(direction_value)); +- int16_t time_value; ++ uint16_t time_value; + memset(&time_value, 0x00, sizeof(time_value)); +- int16_t start_hue_value; ++ uint16_t start_hue_value; + memset(&start_hue_value, 0x00, sizeof(start_hue_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10909,11 +10909,11 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCMoveMode move_mode_value; + memset(&move_mode_value, 0x00, sizeof(move_mode_value)); +- int16_t rate_value; ++ uint16_t rate_value; + memset(&rate_value, 0x00, sizeof(rate_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10940,13 +10940,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CCStepMode step_mode_value; + memset(&step_mode_value, 0x00, sizeof(step_mode_value)); +- int16_t step_size_value; ++ uint16_t step_size_value; + memset(&step_size_value, 0x00, sizeof(step_size_value)); +- int16_t transition_time_value; ++ uint16_t transition_time_value; + memset(&transition_time_value, 0x00, sizeof(transition_time_value)); +- uint8_t * color_temperature_minimum_mireds_value; ++ uint16_t color_temperature_minimum_mireds_value; + memset(&color_temperature_minimum_mireds_value, 0x00, sizeof(color_temperature_minimum_mireds_value)); +- uint8_t * color_temperature_maximum_mireds_value; ++ uint16_t color_temperature_maximum_mireds_value; + memset(&color_temperature_maximum_mireds_value, 0x00, sizeof(color_temperature_maximum_mireds_value)); + uint8_t options_mask_value; + memset(&options_mask_value, 0x00, sizeof(options_mask_value)); +@@ -10975,7 +10975,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + ZoneEnrollResponseEnrollResponseCode enroll_response_code_value; + memset(&enroll_response_code_value, 0x00, sizeof(enroll_response_code_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_enroll_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -10992,9 +10992,9 @@ void test_automatic_deduction_of_supported_commands() + memset(&zone_status_value, 0x00, sizeof(zone_status_value)); + uint8_t extended_status_value; + memset(&extended_status_value, 0x00, sizeof(extended_status_value)); +- int8_t zoneid_value; ++ uint8_t zoneid_value; + memset(&zoneid_value, 0x00, sizeof(zoneid_value)); +- int16_t delay_value; ++ uint16_t delay_value; + memset(&delay_value, 0x00, sizeof(delay_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_status_change_notification_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11020,7 +11020,7 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + IasZoneType zone_type_value; + memset(&zone_type_value, 0x00, sizeof(zone_type_value)); +- int16_t manufacturer_code_value; ++ uint16_t manufacturer_code_value; + memset(&manufacturer_code_value, 0x00, sizeof(manufacturer_code_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_zone_enroll_request_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11033,9 +11033,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback) { + // Dummy command parameters +- int8_t test_mode_duration_value; ++ uint8_t test_mode_duration_value; + memset(&test_mode_duration_value, 0x00, sizeof(test_mode_duration_value)); +- int8_t current_zone_sensitivity_level_value; ++ uint8_t current_zone_sensitivity_level_value; + memset(¤t_zone_sensitivity_level_value, 0x00, sizeof(current_zone_sensitivity_level_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_ias_zone_initiate_test_mode_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11050,9 +11050,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + uint8_t siren_configuration_value; + memset(&siren_configuration_value, 0x00, sizeof(siren_configuration_value)); +- int16_t warning_duration_value; ++ uint16_t warning_duration_value; + memset(&warning_duration_value, 0x00, sizeof(warning_duration_value)); +- int8_t strobe_duty_cycle_value; ++ uint8_t strobe_duty_cycle_value; + memset(&strobe_duty_cycle_value, 0x00, sizeof(strobe_duty_cycle_value)); + IaswdLevel strobe_level_value; + memset(&strobe_level_value, 0x00, sizeof(strobe_level_value)); +@@ -11082,11 +11082,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback) { + // Dummy command parameters +- int8_t profile_count_value; ++ uint8_t profile_count_value; + memset(&profile_count_value, 0x00, sizeof(profile_count_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t max_number_of_intervals_value; ++ uint8_t max_number_of_intervals_value; + memset(&max_number_of_intervals_value, 0x00, sizeof(max_number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_profile_info_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11110,15 +11110,15 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback) { + // Dummy command parameters +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); + GetMeasurementProfileResponseStatus status_value; + memset(&status_value, 0x00, sizeof(status_value)); + ProfileIntervalPeriod profile_interval_period_value; + memset(&profile_interval_period_value, 0x00, sizeof(profile_interval_period_value)); +- int8_t number_of_intervals_delivered_value; ++ uint8_t number_of_intervals_delivered_value; + memset(&number_of_intervals_delivered_value, 0x00, sizeof(number_of_intervals_delivered_value)); +- uint8_t attribute_id_value; ++ uint16_t attribute_id_value; + memset(&attribute_id_value, 0x00, sizeof(attribute_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_response_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11139,11 +11139,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback) { + // Dummy command parameters +- uint8_t attributeid_value; ++ uint16_t attributeid_value; + memset(&attributeid_value, 0x00, sizeof(attributeid_value)); +- uint8_t start_time_value; ++ uint32_t start_time_value; + memset(&start_time_value, 0x00, sizeof(start_time_value)); +- int8_t number_of_intervals_value; ++ uint8_t number_of_intervals_value; + memset(&number_of_intervals_value, 0x00, sizeof(number_of_intervals_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_electrical_measurement_get_measurement_profile_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11164,13 +11164,13 @@ void test_automatic_deduction_of_supported_commands() + memset(&destinationunid_value, 0x00, sizeof(destinationunid_value)); + bool transmission_successful_value; + memset(&transmission_successful_value, 0x00, sizeof(transmission_successful_value)); +- int16_t transmission_time_ms_value; ++ uint16_t transmission_time_ms_value; + memset(&transmission_time_ms_value, 0x00, sizeof(transmission_time_ms_value)); + int8_t tx_powerd_bm_value; + memset(&tx_powerd_bm_value, 0x00, sizeof(tx_powerd_bm_value)); +- int8_t tx_channel_value; ++ uint8_t tx_channel_value; + memset(&tx_channel_value, 0x00, sizeof(tx_channel_value)); +- int8_t routing_attempts_value; ++ uint8_t routing_attempts_value; + memset(&routing_attempts_value, 0x00, sizeof(routing_attempts_value)); + bool route_changed_value; + memset(&route_changed_value, 0x00, sizeof(route_changed_value)); +@@ -11180,7 +11180,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&measured_noise_floord_bm_value, 0x00, sizeof(measured_noise_floord_bm_value)); + int8_t ackrssi_value; + memset(&ackrssi_value, 0x00, sizeof(ackrssi_value)); +- int8_t ack_channel_value; ++ uint8_t ack_channel_value; + memset(&ack_channel_value, 0x00, sizeof(ack_channel_value)); + const char* last_route_failed_link_functionalunid_value; + memset(&last_route_failed_link_functionalunid_value, 0x00, sizeof(last_route_failed_link_functionalunid_value)); +@@ -11283,7 +11283,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_binding_bind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11302,7 +11302,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&cluster_name_value, 0x00, sizeof(cluster_name_value)); + const char* destination_unid_value; + memset(&destination_unid_value, 0x00, sizeof(destination_unid_value)); +- int8_t destination_ep_value; ++ uint8_t destination_ep_value; + memset(&destination_ep_value, 0x00, sizeof(destination_ep_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_binding_unbind_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11362,7 +11362,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback) { + // Dummy command parameters +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11380,7 +11380,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_set_parameter_callback) { + // Dummy command parameters +- int16_t parameter_id_value; ++ uint16_t parameter_id_value; + memset(¶meter_id_value, 0x00, sizeof(parameter_id_value)); + int64_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +@@ -11395,9 +11395,9 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback) { + // Dummy command parameters +- int16_t first_parameter_id_value; ++ uint16_t first_parameter_id_value; + memset(&first_parameter_id_value, 0x00, sizeof(first_parameter_id_value)); +- int16_t last_parameter_id_value; ++ uint16_t last_parameter_id_value; + memset(&last_parameter_id_value, 0x00, sizeof(last_parameter_id_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_configuration_parameters_discover_parameter_range_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11410,7 +11410,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_add_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -11420,7 +11420,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -11445,7 +11445,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_modify_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + UserTypeEnum user_type_value; + memset(&user_type_value, 0x00, sizeof(user_type_value)); +@@ -11455,7 +11455,7 @@ void test_automatic_deduction_of_supported_commands() + memset(&credential_rule_value, 0x00, sizeof(credential_rule_value)); + const char* user_name_value; + memset(&user_name_value, 0x00, sizeof(user_name_value)); +- int16_t expiring_timeout_minutes_value; ++ uint16_t expiring_timeout_minutes_value; + memset(&expiring_timeout_minutes_value, 0x00, sizeof(expiring_timeout_minutes_value)); + UserNameEncodingType user_name_encoding_value; + memset(&user_name_encoding_value, 0x00, sizeof(user_name_encoding_value)); +@@ -11480,7 +11480,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11491,11 +11491,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_add_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -11514,11 +11514,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_modify_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + const char* credential_data_value; + memset(&credential_data_value, 0x00, sizeof(credential_data_value)); +@@ -11537,11 +11537,11 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_credential_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_credential_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11581,7 +11581,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11592,7 +11592,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +@@ -11607,13 +11607,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11630,13 +11630,13 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t credential_slot_value; ++ uint16_t credential_slot_value; + memset(&credential_slot_value, 0x00, sizeof(credential_slot_value)); +- int8_t credential_learn_timeout_value; ++ uint8_t credential_learn_timeout_value; + memset(&credential_learn_timeout_value, 0x00, sizeof(credential_learn_timeout_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11662,13 +11662,13 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + CredType credential_type_value; + memset(&credential_type_value, 0x00, sizeof(credential_type_value)); +- int16_t source_user_uniqueid_value; ++ uint16_t source_user_uniqueid_value; + memset(&source_user_uniqueid_value, 0x00, sizeof(source_user_uniqueid_value)); +- int16_t source_credential_slot_value; ++ uint16_t source_credential_slot_value; + memset(&source_credential_slot_value, 0x00, sizeof(source_credential_slot_value)); +- int16_t destination_user_uniqueid_value; ++ uint16_t destination_user_uniqueid_value; + memset(&destination_user_uniqueid_value, 0x00, sizeof(destination_user_uniqueid_value)); +- int16_t destination_credential_slot_value; ++ uint16_t destination_credential_slot_value; + memset(&destination_credential_slot_value, 0x00, sizeof(destination_credential_slot_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_credential_association_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11687,7 +11687,7 @@ void test_automatic_deduction_of_supported_commands() + } + if (NULL != test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback) { + // Dummy command parameters +- int16_t user_uniqueid_value; ++ uint16_t user_uniqueid_value; + memset(&user_uniqueid_value, 0x00, sizeof(user_uniqueid_value)); + // Invoke with support check + TEST_ASSERT_EQUAL(SL_STATUS_OK, test_uic_mqtt_dotdot_user_credential_get_user_checksum_callback(expected_unid,expected_endpoint_id,UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK +@@ -11772,9 +11772,9 @@ void test_automatic_deduction_of_supported_commands() + // Dummy command parameters + SetpointType type_value; + memset(&type_value, 0x00, sizeof(type_value)); +- int8_t precision_value; ++ uint8_t precision_value; + memset(&precision_value, 0x00, sizeof(precision_value)); +- int8_t scale_value; ++ uint8_t scale_value; + memset(&scale_value, 0x00, sizeof(scale_value)); + int32_t value_value; + memset(&value_value, 0x00, sizeof(value_value)); +-- +2.39.5 + From b0fbea8f20e1b5e7ff874c900ad52c779a624d72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 22 May 2024 14:11:58 +0200 Subject: [PATCH 02/60] UIC-3222: ZPC User Credential Discovery Commands - User Capabilities - Credential Capabilities - All User Checksum - User Get/Report - Credential Get/Report Merged : UIC-3222: Fix Supported Credential Types UIC-3222: Ignore User ID 0 & don't create duplicates UIC-3222: Delayed interview UIC-3222: User Credential User Name Encoding under UUID (No real advantage to put this under USER_NAME) UIC-3222: Fix user discovery UIC-3222: Credential get log UIC-3222: Discovery fix (credential and user get) UIC-3222: Discovery interview remove all users before user interview UIC-3222: Fix credential report if credential data is missing UIC-3222: Remove user if User modifier type is DNE UIC-3222: Correctly remove all user credential before discovery UIC-3222: set_reported_attribute return correct status and undefined desired UIC-3222: Add get_desired user id node function UIC-3222: get_credential_type can now be searched as desired value UIC-3222: Credential Learn Properties [Philippe Coval] Adjusted crc16 in applications/zpc/components/zwave_command_classes/test/CMakeLists.txt --- ...wave_command_class_user_credential_types.h | 63 + .../zwave_command_class_user_credential.cpp | 1351 +++++++++++++ .../src/zwave_command_class_user_credential.h | 40 + ...ave_command_class_user_credential_test.cpp | 1745 +++++++++++++++++ 4 files changed, 3199 insertions(+) create mode 100644 applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h create mode 100644 applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h create mode 100644 applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h new file mode 100644 index 000000000..e6e29800f --- /dev/null +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -0,0 +1,63 @@ +/****************************************************************************** + * # License + * Copyright 2023 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +/** + * @defgroup zwave_command_class_user_credential_types Type definitions for attribute storage of the Sound Switch Command Class + * @ingroup zpc_attribute_store_command_classes_types + * @brief Type definitions for the Sound Switch Command Class. + * + * @{ + */ + +#ifndef ZWAVE_COMMAND_CLASS_USER_CREDENTIALS_TYPES_H +#define ZWAVE_COMMAND_CLASS_USER_CREDENTIALS_TYPES_H + +#include + +///> Supported credential rules bitmask. uint8_t +typedef uint8_t user_credential_supported_credential_rules_t; + +///> Supported user type bitmask. uint32_t +typedef uint32_t user_credential_supported_user_type_bitmask_t; + +///> All user checksum. uint16_t +typedef uint16_t user_credential_all_users_checksum_t; + +///> User Unique ID. uint16_t +typedef uint16_t user_credential_user_unique_id_t; +///> User Modifier Type. uint8_t +typedef uint8_t user_credential_user_modifier_type_t; +///> User Modifier Node ID. uint16_t +typedef uint16_t user_credential_user_modifier_node_id_t; +///> User Type. uint8_t +typedef uint8_t user_credential_user_type_t; + +///> Credential type. uint8_t +typedef uint8_t user_credential_type_t; + +///> Credential slot. uint16_t +typedef uint16_t user_credential_slot_t; + +///> Operation type. uint8_t +typedef uint8_t user_credential_operation_type_t; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} +#endif + +#endif //ZWAVE_COMMAND_CLASS_USER_CREDENTIALS_TYPES_H +/** @} end zwave_command_class_user_credentials_types */ diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp new file mode 100644 index 000000000..af09fceb3 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -0,0 +1,1351 @@ + +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +// System +#include + +#include "zwave_command_class_user_credential.h" +#include "zwave_command_class_user_credential_types.h" +#include "zwave_command_classes_utils.h" +#include "ZW_classcmd.h" + +// Includes from other ZPC Components +#include "zwave_command_class_indices.h" +#include "zwave_command_handler.h" +#include "zwave_command_class_version_types.h" +#include "attribute_store_defined_attribute_types.h" +#include "zpc_attribute_store.h" + +// Unify +#include "attribute_resolver.h" +#include "attribute_store.h" +#include "attribute_store_helper.h" +#include "attribute_store_type_registration.h" +#include "sl_log.h" + +// DotDot +#include "unify_dotdot_attribute_store_node_state.h" + +// Cpp related +#include +#include + +// Macro +#define LOG_TAG "zwave_command_class_user_credential" +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type +// Used to get user names +// If the user name has a size > to this number, we will truncate it +// Specification says that payload data should not exceeded 64 bytes. +#define MAX_CHAR_SIZE 64 + +/** + * @brief Implementation notes + * + * 1. Perform mandatory interview with User and Credentials Capabilities + * 2. Once interview is finished we retrieve all Users/Credentials (see zwave_network_status_changed) + * > To get all Users and Credential we create a new node with a desired value. + * > The lack of reported value will trigger a GET + * > GET will set the reported value so we can get a report for this USER/CREDENTIAL + * + */ + +///////////////////////////////////////////////////////////////////////////// +// Data struct +///////////////////////////////////////////////////////////////////////////// + +struct uint16_exploded { + uint8_t msb; // Most Significant Bit + uint8_t lsb; // Less Significant Bit +}; + +// Used to define reported values +struct user_field_data { + attribute_store_type_t node_type; + uint8_t report_index; + uint8_t bitmask = 0; + uint8_t shift_right = 0; +}; + +///////////////////////////////////////////////////////////////////////////// +// Type Helpers +///////////////////////////////////////////////////////////////////////////// +uint16_t get_uint16_value(const uint8_t *frame, uint16_t start_index) +{ + uint16_t extracted_value = 0; + for (int i = 0; i < 2; i++) { + extracted_value = (extracted_value << 8) | frame[start_index + i]; + } + + return extracted_value; +} + +// Transform a uint16_t into 2 uint8_t +uint16_exploded explode_uint16(uint16_t value) +{ + uint8_t msb = (value & 0xFF00) >> 8; + uint8_t lsb = (value & 0x00FF); + return uint16_exploded {msb, lsb}; +} + +std::string get_string_value(const uint8_t *frame_data, + uint16_t start_index, + uint8_t str_size) +{ + std::string value; + // Check if our name fits our buffer ; if not it is truncated + if (str_size > MAX_CHAR_SIZE) { + sl_log_warning(LOG_TAG, "Invalid char size"); + str_size = MAX_CHAR_SIZE; + } + + for (int i = 0; i < str_size; i++) { + value += frame_data[start_index + i]; + } + + return value; +} + +///////////////////////////////////////////////////////////////////////////// +// Command Class Helper +///////////////////////////////////////////////////////////////////////////// + +/** + * @brief Get user id node + * + * @warning state can't be DESIRED_OR_REPORTED_ATTRIBUTE or it will not work + * + * @param endpoint_node Endpoint point node + * @param user_id User ID to find + * @param state Check reported or desired value. + * @param user_id_node User id node will be stored here if found + * + * @return true User id exists + * @return false User id doesn't exists + */ +bool get_user_id_node(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + attribute_store_node_value_state_t state, + attribute_store_node_t &user_id_node) +{ + user_id_node = attribute_store_get_node_child_by_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + state, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + return attribute_store_node_exists(user_id_node); +} + +/** + * @brief Get node associated with user ID (reported) + * + * @warning This function only checks the reported User Unique + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * + * @return attribute_store_node_t If User ID exists + * @return INVALID_ATTRIBUTE_STORE_NODE If User ID does not exist + */ +attribute_store_node_t + get_reported_user_id_node(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + attribute_store_node_t user_id_node; + get_user_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE, user_id_node); + return user_id_node; +} + +/** + * @brief Get node associated with user ID (desired) + * + * @warning This function only checks the reported User Unique + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * + * @return attribute_store_node_t If User ID exists + * @return INVALID_ATTRIBUTE_STORE_NODE If User ID does not exist + */ +attribute_store_node_t + get_desired_user_id_node(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + attribute_store_node_t user_id_node; + get_user_id_node(endpoint_node, user_id, DESIRED_ATTRIBUTE, user_id_node); + return user_id_node; +} + +/** + * @brief Get credential node associated with credential_type and user_id. + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * @param credential_type Credential type + * @param state Check reported or desired value. + * @param credential_type_node Credential node will be stored here if found + * + * @return true Credential Type exists + * @return false Credential Type doesn't exists + */ +bool get_credential_type_node(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + attribute_store_node_value_state_t state, + attribute_store_node_t &credential_type_node) +{ + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + credential_type_node + = attribute_store_get_node_child_by_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + state, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + + return attribute_store_node_exists(credential_type_node); +} + +/** + * @brief Get credential slot node + * + * @warning state can't be DESIRED_OR_REPORTED_ATTRIBUTE or it will not work + * + * @param credential_type_node Endpoint point node + * @param credential_slot Credential Slot to find + * @param state Check reported or desired value. + * @param credential_slot_node Credential Slot node will be stored here if found + * + * @return true Credential Slot exists + * @return false Credential Slot doesn't exists + */ +bool get_credential_slot_node(attribute_store_node_t credential_type_node, + user_credential_slot_t credential_slot, + attribute_store_node_value_state_t state, + attribute_store_node_t &credential_slot_node) +{ + credential_slot_node + = attribute_store_get_node_child_by_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + state, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + + return attribute_store_node_exists(credential_slot_node); +} + +///////////////////////////////////////////////////////////////////////////// +// Attributes helpers +///////////////////////////////////////////////////////////////////////////// + +/** @brief Set reported attributes based on user_data + * + * @note This function also undefine all desired values + * + * @param base_node Parent node of the newly created attributes + * @param frame_data Frame data to interpret + * @param user_data User data to interpret frame_data + * + * @return sl_status_t SL_STATUS_OK if everything was fine +*/ +sl_status_t + set_reported_attributes(attribute_store_node_t base_node, + const uint8_t *frame_data, + const std::vector &user_data) +{ + sl_status_t status = SL_STATUS_OK; + + for (const auto &field: user_data) { + attribute_store_storage_type_t storage_type + = attribute_store_get_storage_type(field.node_type); + + switch (storage_type) { + case U8_STORAGE_TYPE: { + uint8_t uint8_value = frame_data[field.report_index]; + if (field.bitmask != 0) { + uint8_value = (uint8_value & field.bitmask) >> field.shift_right; + } + status |= attribute_store_set_child_reported(base_node, + field.node_type, + &uint8_value, + sizeof(uint8_value)); + } break; + // Unsigned 16-bit integers are used for this attribute + case U16_STORAGE_TYPE: { + uint16_t uint16_value + = get_uint16_value(frame_data, field.report_index); + status |= attribute_store_set_child_reported(base_node, + field.node_type, + &uint16_value, + sizeof(uint16_value)); + + break; + } + default: + sl_log_error(LOG_TAG, + "Internal error : unsupported storage_type in " + "set_reported_attributes"); + return SL_STATUS_NOT_SUPPORTED; + } + + // Undefined desired value + status + |= attribute_store_set_child_desired(base_node, field.node_type, NULL, 0); + } + + return status; +} + +///////////////////////////////////////////////////////////////////////////// +// Version & Attribute Creation +///////////////////////////////////////////////////////////////////////////// +static void zwave_command_class_user_credential_on_version_attribute_update( + attribute_store_node_t updated_node, attribute_store_change_t change) +{ + if (change == ATTRIBUTE_DELETED) { + return; + } + + zwave_cc_version_t version = 0; + attribute_store_get_reported(updated_node, &version, sizeof(version)); + + if (version == 0) { + return; + } + + sl_log_debug(LOG_TAG, "User Credential version %d", version); + + attribute_store_node_t endpoint_node + = attribute_store_get_first_parent_with_type(updated_node, + ATTRIBUTE_ENDPOINT_ID); + + // The order of the attribute matter since it defines the order of the + // Z-Wave get command order. + const attribute_store_type_t attributes[] = { + ATTRIBUTE(NUMBER_OF_USERS), + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + }; + + attribute_store_add_if_missing(endpoint_node, + attributes, + COUNT_OF(attributes)); +} + +///////////////////////////////////////////////////////////////////////////// +// User Credential User Capabilities Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t zwave_command_class_user_credential_user_capabilities_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "User Capabilities Get"); + + (void)node; // unused. + ZW_USER_CAPABILITIES_GET_FRAME *get_frame + = (ZW_USER_CAPABILITIES_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = USER_CAPABILITIES_GET; + *frame_length = sizeof(ZW_USER_CAPABILITIES_GET_FRAME); + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + constexpr uint8_t INDEX_USER_COUNT = 2; + constexpr uint8_t INDEX_CREDENTIAL_RULES = 4; + constexpr uint8_t INDEX_MAX_LENGTH = 5; + constexpr uint8_t INDEX_SUPPORT_BITS = 6; + constexpr uint8_t INDEX_BITMASK_LENGTH = 7; + + if (frame_length < INDEX_BITMASK_LENGTH) { + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, "User Capabilities Report"); + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + uint16_t user_count = get_uint16_value(frame_data, INDEX_USER_COUNT); + + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS), + &user_count, + sizeof(user_count)); + + user_credential_supported_credential_rules_t credential_rules + = frame_data[INDEX_CREDENTIAL_RULES]; + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), + &credential_rules, + sizeof(credential_rules)); + + uint8_t max_length = frame_data[INDEX_MAX_LENGTH]; + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(MAX_USERNAME_LENGTH), + &max_length, + sizeof(max_length)); + + // Support bits + uint8_t support_bits = frame_data[INDEX_SUPPORT_BITS]; + // Create a lambda function that do what we want for all of the 3 parameters + auto emplace_bool_value = [&support_bits, + &endpoint_node](uint8_t bitmask, + attribute_store_type_t type) { + uint8_t bool_value = (support_bits & bitmask) > 0; + + attribute_store_set_child_reported(endpoint_node, + type, + &bool_value, + sizeof(bool_value)); + + // CL:0083.XX.XX.XX.X : If the All Users Checksum Support field is set in the User Capabilities Report Command, the controlling + // node SHOULD send an All Users Checksum Get Command to check if there are existing Users or + // Credentials present on the supporting node. + if (type == ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM) && bool_value) { + sl_log_debug(LOG_TAG, + "SUPPORT_ALL_USERS_CHECKSUM is set, sending All Users " + "Checksum Get Command"); + const attribute_store_type_t attributes[] = { + ATTRIBUTE(ALL_USERS_CHECKSUM), + }; + // Trigger get ALL_USERS_CHECKSUM + attribute_store_add_if_missing(endpoint_node, + attributes, + COUNT_OF(attributes)); + } + }; + + emplace_bool_value( + USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, + ATTRIBUTE(SUPPORT_USER_SCHEDULE)); + emplace_bool_value( + USER_CAPABILITIES_REPORT_PROPERTIES1_ALL_USERS_CHECKSUM_SUPPORT_BIT_MASK, + ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM)); + emplace_bool_value( + USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, + ATTRIBUTE(SUPPORT_USER_CHECKSUM)); + + // Bit mask support + user_credential_supported_user_type_bitmask_t bitmask = 0x0000; + uint8_t bitmask_length = frame_data[INDEX_BITMASK_LENGTH]; + // Since we are using uint32_t we can't have more that 4 bit mask + if (bitmask_length > 4) { + sl_log_error(LOG_TAG, + "user_credential_supported_user_type_bitmask_t length is not " + "supported\n"); + return SL_STATUS_NOT_SUPPORTED; + } + for (int i = bitmask_length; i > 0; i--) { + bitmask = (bitmask << 8) | frame_data[INDEX_BITMASK_LENGTH + i]; + } + + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(SUPPORTED_USER_TYPES), + &bitmask, + sizeof(bitmask)); + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// User Credential Credential Capabilities Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t + zwave_command_class_user_credential_credential_capabilities_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Capabilities Get"); + + ZW_CREDENTIAL_CAPABILITIES_GET_FRAME *get_frame + = (ZW_CREDENTIAL_CAPABILITIES_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = CREDENTIAL_CAPABILITIES_GET; + *frame_length = sizeof(ZW_CREDENTIAL_CAPABILITIES_GET_FRAME); + return SL_STATUS_OK; +} + +sl_status_t + zwave_command_class_user_credential_credential_capabilities_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length < 5) { + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, "Credential Capabilities Report"); + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + uint8_t support_credential_checksum + = (frame_data[2] + & CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK) + > 0; + + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + &support_credential_checksum, + sizeof(support_credential_checksum)); + + uint8_t supported_credential_types_count = frame_data[3]; + + // Remove all previous known CREDENTIAL_TYPE + attribute_store_node_t type_node; + do { + type_node + = attribute_store_get_node_child_by_type(endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + 0); + attribute_store_delete_node(type_node); + } while (type_node != ATTRIBUTE_STORE_INVALID_NODE); + + uint16_t current_index = 4; + for (uint8_t i = 0; i < supported_credential_types_count; i++) { + // > Root node : Credential Type + user_credential_type_t credential_type = frame_data[current_index]; + + attribute_store_node_t credential_type_node + = attribute_store_emplace(endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + if (credential_type_node == ATTRIBUTE_STORE_INVALID_NODE) { + sl_log_error(LOG_TAG, "Unable to create credential type node"); + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, "Supported credential type : %d", credential_type); + + // >> CL Support + // Use same define as Credential Checksum Support here since it's a same and no define is available for cl support + uint8_t cl_support_index = current_index + supported_credential_types_count; + uint8_t support_cl + = (frame_data[cl_support_index] + & CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK) + > 0; + + attribute_store_set_child_reported( + credential_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_READ_BACK_SUPPORT), + &support_cl, + sizeof(support_cl)); + + // >> 16 bits values + auto store_uint16_value = [&](attribute_store_type_t type, uint8_t offset) { + // First 16bit value after CL Support is cl_support_index + supported_credential_types_count + // Then we add the 16 bit value offset to it : + // - CREDENTIAL_SUPPORTED_SLOT_COUNT [0] : supported_credential_types_count x 2 x [0] (base) + // - CREDENTIAL_MIN_LENGTH [1] : supported_credential_types_count x 2 x [1] (one batch of 16 bit data before) + // - CREDENTIAL_MAX_LENGTH [2] : supported_credential_types_count x 2 x [2] (two batch of 16 bit data before) + // Then we add i to it (0..n) to make sure we take the right pair of data to form the 16 bit unsigned integer + const uint16_t index = cl_support_index + supported_credential_types_count + + (supported_credential_types_count * 2 * offset) + + i; + uint16_t value = get_uint16_value(frame_data, index); + attribute_store_set_child_reported(credential_type_node, + type, + &value, + sizeof(value)); + }; + + store_uint16_value(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), 0); + store_uint16_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH), 1); + store_uint16_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH), 2); + + current_index++; + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// All User Checksum Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t zwave_command_class_user_credential_all_user_checksum_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "All User Checksum Get"); + + ZW_ALL_USERS_CHECKSUM_GET_FRAME *get_frame + = (ZW_ALL_USERS_CHECKSUM_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = ALL_USERS_CHECKSUM_GET; + *frame_length = sizeof(ZW_ALL_USERS_CHECKSUM_GET_FRAME); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length != 4) { + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, "All User Checksum Report"); + + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + user_credential_all_users_checksum_t all_users_checksum + = get_uint16_value(frame_data, 2); + + attribute_store_set_child_reported(endpoint_node, + ATTRIBUTE(ALL_USERS_CHECKSUM), + &all_users_checksum, + sizeof(all_users_checksum)); + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Credential Get/Report +///////////////////////////////////////////////////////////////////////////// + +// Start credential interview process by starting with 0,0 +void trigger_get_credential(attribute_store_node_t user_unique_id_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + sl_log_debug(LOG_TAG, + "Trigger GET credential for user %d : " + "Credential type %d, credential slot %d", + static_cast(attribute_store_get_reported_number(user_unique_id_node)), + credential_type, + credential_slot); + + // Create credential type node if it doesn't exists + // Since the GET is mapped to the Credential SLOT we doesn't need to do anything specific here + attribute_store_node_t credential_type_node + = attribute_store_emplace(user_unique_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + // Then check if credential slot node exists + attribute_store_node_t credential_slot_node + = attribute_store_get_node_child_by_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + + // If it exists we clear it reported value and set it as desired + if (attribute_store_node_exists(credential_slot_node)) { + attribute_store_set_desired(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + attribute_store_undefine_reported(credential_slot_node); + } else { // If non existant we create it + attribute_store_emplace_desired(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + } +} + +/** + * @brief Credential GET + * + * Attribute store IN : + * CREDENTIAL_TYPE : desired value => get_frame->credentialType + * CREDENTIAL_SLOT : desired value => get_frame->credentialSlot1 & credentialSlot2 + * USER_UNIQUE_ID : reported value => get_frame->userUniqueIdentifier1 & userUniqueIdentifier2 + * + * Attribute store OUT : + * CREDENTIAL_TYPE : set reported as desired & clear desired + * CREDENTIAL_SLOT : set reported as desired & clear desired + * + * @param credential_slot_node + * @param frame + * @param frame_length + * @return sl_status_t + */ +static sl_status_t zwave_command_class_user_credential_credential_get( + attribute_store_node_t credential_slot_node, + uint8_t *frame, + uint16_t *frame_length) +{ + user_credential_slot_t credential_slot = 0; + sl_status_t status = attribute_store_get_desired(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't get credential slot value. Not sending CREDENTIAL_GET."); + return SL_STATUS_NOT_SUPPORTED; + } + + // Get Credential type + user_credential_type_t credential_type = 0; + attribute_store_node_t credential_type_node + = attribute_store_get_first_parent_with_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + status = attribute_store_get_reported(credential_type_node, + &credential_type, + sizeof(credential_type)); + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get credential_type. Not sending CREDENTIAL_GET."); + return SL_STATUS_NOT_SUPPORTED; + } + + // Get User Node + attribute_store_node_t user_unique_id_node + = attribute_store_get_first_parent_with_type(credential_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); + user_credential_user_unique_id_t user_unique_id; + status = attribute_store_get_reported(user_unique_id_node, + &user_unique_id, + sizeof(user_unique_id)); + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get user_unique_id. Not sending CREDENTIAL_GET."); + return SL_STATUS_NOT_SUPPORTED; + } + + // Log credential node, type, and user ID + sl_log_debug( + LOG_TAG, + "Credential Get. Credential slot: %d / Credential Type: %d (User %d)", + credential_slot, + credential_type, + user_unique_id); + + auto exploded_credential_slot = explode_uint16(credential_slot); + auto exploded_user_id = explode_uint16(user_unique_id); + + ZW_CREDENTIAL_GET_FRAME *get_frame = (ZW_CREDENTIAL_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = CREDENTIAL_GET; + get_frame->userUniqueIdentifier1 = exploded_user_id.msb; + get_frame->userUniqueIdentifier2 = exploded_user_id.lsb; + get_frame->credentialType = credential_type; + get_frame->credentialSlot1 = exploded_credential_slot.msb; + get_frame->credentialSlot2 = exploded_credential_slot.lsb; + + *frame_length = sizeof(ZW_CREDENTIAL_GET_FRAME); + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + // Since INDEX_CREDENTIAL_DATA is a variable length field we know that we at lest expect 16 elements + if (frame_length < 15) { + return SL_STATUS_NOT_SUPPORTED; + } + + constexpr uint8_t INDEX_USER_ID = 2; + constexpr uint8_t INDEX_CREDENTIAL_TYPE = 4; + constexpr uint8_t INDEX_CREDENTIAL_SLOT = 5; + constexpr uint8_t INDEX_CREDENTIAL_READ_BACK = 7; + constexpr uint8_t INDEX_CREDENTIAL_LENGTH = 8; + constexpr uint8_t INDEX_CREDENTIAL_DATA = 9; + const uint8_t credential_length = frame_data[INDEX_CREDENTIAL_LENGTH]; + const uint8_t INDEX_CREDENTIAL_MODIFIER_TYPE + = INDEX_CREDENTIAL_DATA + credential_length; + const uint8_t INDEX_CREDENTIAL_MODIFIER_NODE_ID + = INDEX_CREDENTIAL_MODIFIER_TYPE + 1; + const uint8_t INDEX_NEXT_CREDENTIAL_TYPE + = INDEX_CREDENTIAL_MODIFIER_NODE_ID + 2; + const uint8_t INDEX_NEXT_CREDENTIAL_SLOT = INDEX_NEXT_CREDENTIAL_TYPE + 1; + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + const user_credential_user_unique_id_t user_id + = get_uint16_value(frame_data, INDEX_USER_ID); + const user_credential_type_t credential_type + = frame_data[INDEX_CREDENTIAL_TYPE]; + const user_credential_slot_t credential_slot + = get_uint16_value(frame_data, INDEX_CREDENTIAL_SLOT); + + auto remove_credential_type_and_slot_0_if_exists = [&]() { + attribute_store_node_t type_node_0; + attribute_store_node_t slot_node_0; + + // Get nodes 0 + get_credential_type_node(endpoint_node, user_id, 0, REPORTED_ATTRIBUTE, type_node_0); + get_credential_slot_node(type_node_0, 0, DESIRED_ATTRIBUTE, slot_node_0); + + // Remove them + attribute_store_delete_node(type_node_0); + attribute_store_delete_node(slot_node_0); + }; + + if (credential_type == 0 || credential_slot == 0) { + sl_log_debug(LOG_TAG, "User %d has no credential to get", user_id); + remove_credential_type_and_slot_0_if_exists(); + sl_log_debug(LOG_TAG, "Removed credential type and slot 0"); + return SL_STATUS_OK; + } + + sl_log_debug( + LOG_TAG, + "Credential Report. Credential Type: %d / Credential Slot: %d (User %d)", + credential_type, + credential_slot, + user_id); + + // We should have a valid user id if we receive this report + attribute_store_node_t user_unique_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + // Check node existence + if (!attribute_store_node_exists(user_unique_id_node)) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d in CREDENTIAL_REPORT", + user_id); + return SL_STATUS_NOT_SUPPORTED; + } + + // Find credential type node based on user id and credential type + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + + bool credential_type_found = get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + + // If not found we look for the credential type node of 0 (first interview) + if (!credential_type_found) { + // We don't care about the return value, if not defined it will be catch soon. + get_credential_type_node(endpoint_node, + user_id, + 0, + REPORTED_ATTRIBUTE, + credential_type_node); + } + + // Now search for the slot node + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + // Check reported value first + if (!get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node)) { + sl_log_debug(LOG_TAG, + "Could not find slot %d with reported value, trying desired", + credential_slot); + // Then check desired value + if (!get_credential_slot_node(credential_type_node, + credential_slot, + DESIRED_ATTRIBUTE, + credential_slot_node)) { + sl_log_debug( + LOG_TAG, + "Could not find slot %d with desired value, using the Slot with ID 0", + credential_slot); + + // If not found it will be checked in the next step + get_credential_slot_node(credential_type_node, + 0, + DESIRED_ATTRIBUTE, + credential_slot_node); + } + } + + // Check if we could retrieve all the node we need + if (!attribute_store_node_exists(credential_type_node) + || !attribute_store_node_exists(credential_slot_node)) { + sl_log_error(LOG_TAG, + "Can't find (Credential Type %d, Credential Slot %d) in " + "CREDENTIAL_REPORT", + credential_type, + credential_slot); + return SL_STATUS_NOT_SUPPORTED; + } + + // Update credential slot node & type + attribute_store_set_reported(credential_type_node, + &credential_type, + sizeof(credential_type)); + attribute_store_set_reported(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + // Since the get is listened on the credential slot node we need to clear it + attribute_store_undefine_desired(credential_slot); + + // If there is any leftovers of slot 0 we remove them to prevent infinite loop + remove_credential_type_and_slot_0_if_exists(); + + // Set standard (uint8 & uint16) data + std::vector user_data = { + {ATTRIBUTE(CREDENTIAL_READ_BACK), + INDEX_CREDENTIAL_READ_BACK, + CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, + 7}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), INDEX_CREDENTIAL_MODIFIER_TYPE}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), INDEX_CREDENTIAL_MODIFIER_NODE_ID}, + }; + + sl_status_t status + = set_reported_attributes(credential_slot_node, frame_data, user_data); + + if (status != SL_STATUS_OK) { + return status; + } + + // Set credential data + auto credential_data_length_node + = attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &credential_length, + sizeof(credential_length)); + + if (credential_data_length_node == ATTRIBUTE_STORE_INVALID_NODE) { + sl_log_error(LOG_TAG, + "Can't set CREDENTIAL_DATA_LENGTH in attribute store"); + return SL_STATUS_NOT_SUPPORTED; + } + + status + = attribute_store_set_child_reported(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + &frame_data[INDEX_CREDENTIAL_DATA], + credential_length); + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Can't set CREDENTIAL_DATA in attribute store"); + return SL_STATUS_NOT_SUPPORTED; + } + + user_credential_type_t next_credential_type + = frame_data[INDEX_NEXT_CREDENTIAL_TYPE]; + user_credential_slot_t next_credential_slot + = get_uint16_value(frame_data, INDEX_NEXT_CREDENTIAL_SLOT); + + if (next_credential_type != 0 && next_credential_slot != 0) { + trigger_get_credential(user_unique_id_node, + next_credential_type, + next_credential_slot); + sl_log_debug(LOG_TAG, + "Next credential type and slot: %d, %d", + next_credential_type, + next_credential_slot); + } else { + sl_log_debug(LOG_TAG, "No more credential to get"); + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// User Get/Report +///////////////////////////////////////////////////////////////////////////// + +// Start user interview process by starting a user get with ID 0 +void trigger_get_user(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + // If we are not in the special case of user ID 0 we need to check if user is already here + if (user_id != 0) { + attribute_store_node_t user_node + = attribute_store_get_node_child_by_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + // If it exists we interview it again + if (attribute_store_node_exists(user_node)) { + sl_log_debug(LOG_TAG, "User Unique ID %d found. Undefine its reported value to update it.", user_id); + attribute_store_set_desired(user_node, &user_id, sizeof(user_id)); + attribute_store_undefine_reported(user_node); + return; + } + } + + // If user id is 0 or not existant we create it + sl_log_debug(LOG_TAG, "Creating User Unique ID node %d", user_id); + attribute_store_emplace_desired(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); +} + +static sl_status_t zwave_command_class_user_credential_user_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + user_credential_user_unique_id_t user_id = 0; + sl_status_t status + = attribute_store_get_desired(node, &user_id, sizeof(user_id)); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get user unique id value. Not sending USER_GET."); + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, "User Get for user %d", user_id); + + auto exploded_value = explode_uint16(user_id); + + ZW_USER_GET_FRAME *get_frame = (ZW_USER_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = USER_GET; + get_frame->userUniqueIdentifier1 = exploded_value.msb; + get_frame->userUniqueIdentifier2 = exploded_value.lsb; + + *frame_length = sizeof(ZW_USER_GET_FRAME); + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_user_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + constexpr uint8_t INDEX_NEXT_USER_ID = 2; + constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 4; + constexpr uint8_t INDEX_USER_MODIFIER_ID = 5; + constexpr uint8_t INDEX_USER_ID = 7; + constexpr uint8_t INDEX_USER_TYPE = 9; + constexpr uint8_t INDEX_USER_ACTIVE_STATE = 10; + constexpr uint8_t INDEX_CREDENTIAL_RULE = 11; + constexpr uint8_t INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES = 12; + constexpr uint8_t INDEX_USER_NAME_ENCODING = 14; + constexpr uint8_t INDEX_USER_NAME_LENGTH = 15; + constexpr uint8_t INDEX_USER_NAME = 16; + + if (frame_length < INDEX_USER_NAME) { + return SL_STATUS_NOT_SUPPORTED; + } + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // Find the user + const user_credential_user_unique_id_t user_id + = get_uint16_value(frame_data, INDEX_USER_ID); + + sl_log_debug(LOG_TAG, "User report for user %d", user_id); + + auto remove_node_0_if_exists = [&]() { + attribute_store_node_t node_0; + get_user_id_node(endpoint_node, 0, DESIRED_ATTRIBUTE, node_0); + return attribute_store_delete_node(node_0); + }; + + // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node + if (user_id == 0) { + sl_log_info(LOG_TAG, + "User report with ID 0 received. This probably means that no " + "user is defined on the device."); + sl_log_debug(LOG_TAG, "Attempt to delete User Node ID with value %d", user_id); + sl_status_t deletion_status = remove_node_0_if_exists(); + sl_log_debug(LOG_TAG, "Deletion returned status : %d", deletion_status); + return SL_STATUS_OK; + } + + // Get User ID node + attribute_store_node_t user_unique_id_node; + + // First we check if there this user already exists in our database (reported value) + if (!get_user_id_node(endpoint_node, + user_id, + REPORTED_ATTRIBUTE, + user_unique_id_node)) { + sl_log_debug(LOG_TAG, + "Could not find user %d with reported value, trying desired", + user_id); + // If User node doesn't exists with given desired attribute + if (!get_user_id_node(endpoint_node, + user_id, + DESIRED_ATTRIBUTE, + user_unique_id_node)) { + sl_log_debug( + LOG_TAG, + "Could not find user %d with desired value, using the User ID 0", + user_id); + + // If not found it will be checked in the next step + get_user_id_node(endpoint_node, + 0, + DESIRED_ATTRIBUTE, + user_unique_id_node); + } + } + + // Check node existence + if (!attribute_store_node_exists(user_unique_id_node)) { + sl_log_error(LOG_TAG, "Can't find user with ID %d in USER_REPORT", user_id); + return SL_STATUS_NOT_SUPPORTED; + } + + // Check if user still exists + if (frame_data[INDEX_USER_MODIFIER_TYPE] == USER_REPORT_DNE) { + sl_log_debug(LOG_TAG, "User %d does not exist anymore, removing from attribute store.", user_id); + attribute_store_delete_node(user_unique_id_node); + return SL_STATUS_OK; + } + + // Set reported value + attribute_store_set_reported(user_unique_id_node, &user_id, sizeof(user_id)); + attribute_store_undefine_desired(user_unique_id_node); + + // Remove leftover of node 0 if it exists + // This is necessary if we are interviewing again the user as this node will be left undefined + // and causing a get loop. + remove_node_0_if_exists(); + + // Set standard (uint8 & uint16) data + std::vector user_data + = {{ATTRIBUTE(USER_MODIFIER_TYPE), INDEX_USER_MODIFIER_TYPE}, + {ATTRIBUTE(USER_MODIFIER_NODE_ID), INDEX_USER_MODIFIER_ID}, + {ATTRIBUTE(USER_TYPE), INDEX_USER_TYPE}, + {ATTRIBUTE(USER_ACTIVE_STATE), + INDEX_USER_ACTIVE_STATE, + USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK}, + {ATTRIBUTE(USER_NAME_ENCODING), + INDEX_USER_NAME_ENCODING, + USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK}, + {ATTRIBUTE(CREDENTIAL_RULE), INDEX_CREDENTIAL_RULE}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES} + }; + + sl_status_t set_status + = set_reported_attributes(user_unique_id_node, frame_data, user_data); + + if (set_status != SL_STATUS_OK) { + return set_status; + } + + // User name + uint8_t user_name_length = frame_data[INDEX_USER_NAME_LENGTH]; + std::string user_name + = get_string_value(frame_data, INDEX_USER_NAME, user_name_length); + + // Prevent duplicate + auto user_name_node = attribute_store_get_first_child_by_type( + user_unique_id_node, ATTRIBUTE(USER_NAME)); + if (!attribute_store_node_exists(user_name_node)) { + user_name_node = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_unique_id_node); + } + attribute_store_set_reported_string(user_name_node, user_name.c_str()); + + // Get credentials + trigger_get_credential(user_unique_id_node, 0, 0); + + // Interview next ID if needed + user_credential_user_unique_id_t next_user_id + = get_uint16_value(frame_data, INDEX_NEXT_USER_ID); + if (next_user_id != 0) { + sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); + trigger_get_user(endpoint_node, next_user_id); + } else { + sl_log_debug(LOG_TAG, "No more users to discover"); + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Post interview actions +///////////////////////////////////////////////////////////////////////////// +void zwave_network_status_changed(attribute_store_node_t updated_node, + attribute_store_change_t change) +{ + attribute_store_node_t node_id_node + = attribute_store_get_first_parent_with_type(updated_node, + ATTRIBUTE_NODE_ID); + + zwave_node_id_t node_id; + attribute_store_get_reported(node_id_node, &node_id, sizeof(node_id)); + + // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything + if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { + return; + } + + NodeStateNetworkStatus network_status; + sl_status_t reported_value_status + = attribute_store_get_reported(updated_node, + &network_status, + sizeof(network_status)); + + // If the endpoint report is marked as ONLINE_FUNCTIONAL + if (reported_value_status == SL_STATUS_OK + && network_status == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) + { + sl_log_debug(LOG_TAG, + "Node %d is now ONLINE_FUNCTIONAL : start the delayed " + "interview process", + node_id); + // Perform action on each endpoint that supports User Credential Command class + uint8_t endpoint_count + = attribute_store_get_node_child_count_by_type(node_id_node, + ATTRIBUTE_ENDPOINT_ID); + + sl_log_debug(LOG_TAG, "Checking endpoints (total : %d)...", endpoint_count); + + for (uint8_t i = 0; i < endpoint_count; i++) { + // Get current endpoint node + attribute_store_node_t endpoint_node + = attribute_store_get_node_child_by_type(node_id_node, + ATTRIBUTE_ENDPOINT_ID, + i); + + + zwave_endpoint_id_t endpoint_id; + attribute_store_get_reported(endpoint_node, + &endpoint_id, + sizeof(endpoint_id)); + // Check if the endpoint supports User Credential Command class + if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, + node_id, + endpoint_id)) { + auto user_count = attribute_store_get_node_child_count_by_type( + endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID)); + sl_log_debug(LOG_TAG, + "Endpoint %d supports User Credential. Removing all " + "existing user nodes (%d)...", + i, + user_count); + for (size_t j = 0; j < user_count; j++) { + // Delete the first attribute we find until we have no more left + attribute_store_node_t user_node + = attribute_store_get_node_child_by_type(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + 0); + attribute_store_delete_node(user_node); + } + + sl_log_debug(LOG_TAG, "Starting User and Credential interview"); + // Start the interview process with user ID = 0 + trigger_get_user(endpoint_node, 0); + } + } + } +} + +///////////////////////////////////////////////////////////////////////////// +// Class logic +///////////////////////////////////////////////////////////////////////////// + +// Control handler +sl_status_t zwave_command_class_user_credential_control_handler( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length <= COMMAND_INDEX) { + return SL_STATUS_NOT_SUPPORTED; + } + + switch (frame_data[COMMAND_INDEX]) { + case USER_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_user_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_credential_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case ALL_USERS_CHECKSUM_REPORT: + return zwave_command_class_user_credential_all_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); + case USER_REPORT: + return zwave_command_class_user_credential_user_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_REPORT: + return zwave_command_class_user_credential_credential_handle_report( + connection_info, + frame_data, + frame_length); + default: + return SL_STATUS_NOT_SUPPORTED; + } +} + + + +// Entry point +sl_status_t zwave_command_class_user_credential_init() +{ + attribute_store_register_callback_by_type( + &zwave_command_class_user_credential_on_version_attribute_update, + ATTRIBUTE(VERSION)); + + attribute_resolver_register_rule( + ATTRIBUTE(NUMBER_OF_USERS), + NULL, + &zwave_command_class_user_credential_user_capabilities_get); + + attribute_resolver_register_rule( + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_capabilities_get); + + attribute_resolver_register_rule( + ATTRIBUTE(ALL_USERS_CHECKSUM), + NULL, + &zwave_command_class_user_credential_all_user_checksum_get); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_UNIQUE_ID), + NULL, + &zwave_command_class_user_credential_user_get); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_SLOT), + NULL, + &zwave_command_class_user_credential_credential_get); + + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 + // Discussion about delaying the user interview process after the inclusion + + // Proposed Unify-way to delay users get AFTER interview process + attribute_store_register_callback_by_type( + &zwave_network_status_changed, + DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS); + + zwave_command_handler_t handler = {}; + handler.support_handler = NULL; + handler.control_handler = zwave_command_class_user_credential_control_handler; + // CHECKME : Is this right ? + handler.minimal_scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS; + handler.manual_security_validation = false; + handler.command_class = COMMAND_CLASS_USER_CREDENTIAL; + handler.version = 1; + handler.command_class_name = "User Credential"; + handler.comments = "Experimental"; + + return zwave_command_handler_register_handler(handler); +} \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h new file mode 100644 index 000000000..9af030a3b --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -0,0 +1,40 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +/** + * @defgroup zwave_command_class_user_credential + * @brief Sound Switch Command Class handlers and control function + * + * This module implement some of the functions to control the + * Sound Switch Command Class + * + * @{ + */ + +#ifndef ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_H +#define ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_H + +#include "sl_status.h" + +#ifdef __cplusplus +extern "C" { +#endif + +sl_status_t zwave_command_class_user_credential_init(); + +#ifdef __cplusplus +} +#endif + +#endif //ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_H + /** @} end zwave_command_class_user_credential */ \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp new file mode 100644 index 000000000..77aecbf84 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -0,0 +1,1745 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ +#include +#include "workaround_for_test.hpp" + +extern "C" { + +#include "zwave_command_class_user_credential.h" +#include "zwave_command_class_user_credential_types.h" +#include "zwave_command_classes_utils.h" +#include "unity.h" + +// Generic includes +#include + +// Includes from other components +#include "datastore.h" +#include "attribute_store.h" +#include "attribute_store_helper.h" +#include "attribute_store_fixt.h" +#include "attribute_store_type_registration.h" +#include "zpc_attribute_store_type_registration.h" + +// Interface includes +#include "attribute_store_defined_attribute_types.h" +#include "ZW_classcmd.h" +#include "zwave_utils.h" +#include "zwave_controller_types.h" + +// Test helpers +#include "zpc_attribute_store_test_helper.h" + +// Mock includes +#include "attribute_resolver_mock.h" +#include "zpc_attribute_resolver_mock.h" +#include "zwave_command_handler_mock.h" +#include "dotdot_mqtt_mock.h" +#include "dotdot_mqtt_generated_commands_mock.h" +// Used for delayed interview +#include "zwave_network_management_mock.h" + +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +static zwave_command_handler_t handler = {}; + +// This assumes that XXX_GET and XXX_SET id are > 0 +struct bound_functions { + uint8_t get_func_id; + uint8_t set_func_id; +}; +static std::map attributes_binding = { + {ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, + {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, +}; + +// Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on +// attributes_binding map. +// +// e.g : resolver_functions[USER_CAPABILITIES_GET] = user_capabilities_get_func() +static std::map resolver_functions; + +// Buffer for frame +static uint8_t received_frame[255] = {}; +static uint16_t received_frame_size = 0; + +///////////////////////////////////////////////////// +// C++ HELPERS +///////////////////////////////////////////////////// +} // Extern C + +#ifdef __cplusplus +template void helper_test_attribute_store_values( + std::map attribute_map_values, + attribute_store_node_t parent = ATTRIBUTE_STORE_INVALID_NODE) +{ + if (parent == ATTRIBUTE_STORE_INVALID_NODE) { + parent = endpoint_id_node; + } + + for (auto &attr: attribute_map_values) { + T value; + sl_status_t status = attribute_store_get_child_reported(parent, + attr.first, + &value, + sizeof(value)); + + std::string message + = "Can't get reported value of " + + std::string(attribute_store_get_type_name(attr.first)); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); + + message = "Mismatch value for attribute : " + + std::string(attribute_store_get_type_name(attr.first)); + TEST_ASSERT_EQUAL_MESSAGE(attr.second, value, message.c_str()); + } +} +#endif + +extern "C" { +///////////////////////////////////////////////////// +// HELPERS +///////////////////////////////////////////////////// +struct uint16_exploded { + uint8_t msb; // Most Significant Bit + uint8_t lsb; // Less Significant Bit +}; +uint16_exploded explode_uint16(uint16_t value) +{ + uint8_t msb = (value & 0xFF00) >> 8; + uint8_t lsb = (value & 0x00FF); + return uint16_exploded {msb, lsb}; +} + +struct credential_structure_nodes { + attribute_store_node_t user_id_node; + attribute_store_node_t credential_type_node; + attribute_store_node_t credential_slot_node; +}; + +/** + * @brief Create credential structure and return associated nodes + * + * @param user_id + * @param credential_type + * @param credential_slot + * @param value_state If DESIRED_ATTRIBUTE : credential_type/credential_slot will have their desired value setup, reported otherwise + * @return credential_structure_nodes + */ +credential_structure_nodes + helper_create_credential_structure(user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + attribute_store_node_value_state_t value_state = DESIRED_ATTRIBUTE) +{ + credential_structure_nodes nodes; + nodes.user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + // It should be always reported + nodes.credential_type_node + = attribute_store_emplace(nodes.user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + if (value_state == DESIRED_ATTRIBUTE) { + nodes.credential_slot_node + = attribute_store_emplace_desired(nodes.credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + } else { + nodes.credential_slot_node + = attribute_store_emplace(nodes.credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + } + + return nodes; +} + +void helper_test_get_no_args_happy_case(uint8_t get_command_id) +{ + auto &get_func = resolver_functions[get_command_id]; + + // Ask for a Get Command, should always be the same + TEST_ASSERT_NOT_NULL_MESSAGE( + get_func, + "Couldn't find get function in resolver_functions."); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + get_func(0, received_frame, &received_frame_size), + "Get function should have returned OK"); + + const uint8_t expected_frame[] + = {COMMAND_CLASS_USER_CREDENTIAL, get_command_id}; + TEST_ASSERT_EQUAL_MESSAGE(sizeof(expected_frame), + received_frame_size, + "Get frame size is incorrect"); + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_frame, + received_frame, + received_frame_size, + "Get frame contents mismatch"); +} + +/// @brief Test given GET function with args +/// Can also test if GET command return SL_STATUS_NOT_SUPPORTED if node == INVALID_STORAGE_TYPE +/// @param get_command_id Get command that should be in resolver_functions +/// @param base_node Base node on which the GET function will be called. If INVALID_STORAGE_TYPE expect the GET function to return SL_STATUS_NOT_SUPPORTED and return. +/// @param nodes Node data that will be used to check and construct the GET frame (order matter since the first one will be the first argument, etc..) +void helper_test_get_with_args( + uint8_t get_command_id, + attribute_store_node_t base_node, + std::vector< + std::pair> nodes + = {}) +{ + auto &get_func = resolver_functions[get_command_id]; + + // Ask for a Get Command, should always be the same + TEST_ASSERT_NOT_NULL_MESSAGE( + get_func, + "Couldn't find get function in resolver_functions."); + + if (base_node == ATTRIBUTE_STORE_INVALID_NODE) { + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_NOT_SUPPORTED, + get_func(base_node, received_frame, &received_frame_size), + "Command function should have returned SL_STATUS_NOT_SUPPORTED since no " + "node " + "was provided"); + return; + } + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_func(base_node, received_frame, &received_frame_size), + "Get function should have returned OK"); + + std::vector expected_frame + = {COMMAND_CLASS_USER_CREDENTIAL, get_command_id}; + + for (auto &node_data: nodes) { + auto node = node_data.first; + auto node_value_state = node_data.second; + + auto node_type = attribute_store_get_node_type(node); + auto node_storage_type = attribute_store_get_storage_type(node_type); + + sl_status_t status; + switch (node_storage_type) { + case U8_STORAGE_TYPE: { + uint8_t uint8_value; + status = attribute_store_read_value(node, + node_value_state, + &uint8_value, + sizeof(uint8_value)); + expected_frame.push_back(uint8_value); + } break; + case U16_STORAGE_TYPE: { + uint16_t uint16_value; + status = attribute_store_read_value(node, + node_value_state, + &uint16_value, + sizeof(uint16_value)); + auto exploded_uint16 = explode_uint16(uint16_value); + expected_frame.push_back(exploded_uint16.msb); + expected_frame.push_back(exploded_uint16.lsb); + } break; + // Variable length field + case BYTE_ARRAY_STORAGE_TYPE: { + // Length node should be a parent of the data node + auto data_length_node = attribute_store_get_node_parent(node); + + uint8_t data_length = 0; + attribute_store_read_value(data_length_node, + node_value_state, + &data_length, + sizeof(data_length)); + if (data_length == 0) { + TEST_FAIL_MESSAGE( + "Can't get data_length for BYTE_ARRAY_STORAGE_TYPE type"); + } + + std::vector data; + data.resize(data_length); + status = attribute_store_read_value(node, + node_value_state, + data.data(), + data_length); + + expected_frame.push_back(data_length); + for (uint8_t i = 0; i < data_length; i++) { + expected_frame.push_back(data[i]); + } + + } break; + + default: + TEST_FAIL_MESSAGE( + "Unkown storage type in helper_test_get_with_args_happy_case"); + } + + std::string message + = "Should be able to get value of " + + std::string(attribute_store_type_get_node_type_name(node)); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); + } + + TEST_ASSERT_EQUAL_MESSAGE(expected_frame.size(), + received_frame_size, + "Get frame size is incorrect"); + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_frame.data(), + received_frame, + received_frame_size, + "Get frame contents mismatch"); +} + +void helper_test_string_value( + std::map attribute_map_values, + attribute_store_node_t parent = ATTRIBUTE_STORE_INVALID_NODE) +{ + if (parent == ATTRIBUTE_STORE_INVALID_NODE) { + parent = endpoint_id_node; + } + + for (auto &attr: attribute_map_values) { + constexpr uint8_t MAX_CHAR_SIZE = 64; + char reported_c_str[MAX_CHAR_SIZE]; + + auto str_node = attribute_store_get_first_child_by_type(parent, attr.first); + sl_status_t status = attribute_store_get_reported_string(str_node, + reported_c_str, + MAX_CHAR_SIZE); + + std::string message + = "Can't get string reported value of " + + std::string(attribute_store_get_type_name(attr.first)); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); + + message = "Mismatch value for attribute : " + + std::string(attribute_store_get_type_name(attr.first)); + TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(attr.second.c_str(), + reported_c_str, + attr.second.size() + 1, + message.c_str()); + } +} + +///////////////////////////////////////////////////// +// Test case +///////////////////////////////////////////////////// +// Stub functions +static sl_status_t + attribute_resolver_register_rule_stub(attribute_store_type_t node_type, + attribute_resolver_function_t set_func, + attribute_resolver_function_t get_func, + int cmock_num_calls) +{ + if (attributes_binding.find(node_type) != attributes_binding.end()) { + const auto func = attributes_binding[node_type]; + + if (func.get_func_id == 0) { + TEST_ASSERT_NULL(get_func); + } else { + TEST_ASSERT_NOT_NULL(get_func); + resolver_functions[func.get_func_id] = get_func; + } + + if (func.set_func_id == 0) { + TEST_ASSERT_NULL(set_func); + } else { + TEST_ASSERT_NOT_NULL(set_func); + resolver_functions[func.set_func_id] = set_func; + } + } + + return SL_STATUS_OK; +} + +static sl_status_t zwave_command_handler_register_handler_stub( + zwave_command_handler_t new_command_class_handler, int cmock_num_calls) +{ + handler = new_command_class_handler; + + TEST_ASSERT_EQUAL(ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS, + handler.minimal_scheme); + TEST_ASSERT_EQUAL(COMMAND_CLASS_USER_CREDENTIAL, handler.command_class); + TEST_ASSERT_EQUAL(1, handler.version); + TEST_ASSERT_NOT_NULL(handler.control_handler); + TEST_ASSERT_NULL(handler.support_handler); + TEST_ASSERT_FALSE(handler.manual_security_validation); + + return SL_STATUS_OK; +} + +/// Setup the test suite (called once before all test_xxx functions are called) +void suiteSetUp() +{ + datastore_init(":memory:"); + attribute_store_init(); + zpc_attribute_store_register_known_attribute_types(); +} + +/// Teardown the test suite (called once after all test_xxx functions are called) +int suiteTearDown(int num_failures) +{ + attribute_store_teardown(); + datastore_teardown(); + return num_failures; +} + +/// Called before each and every test +void setUp() +{ + zwave_network_management_get_node_id_IgnoreAndReturn(zpc_node_id); + zwave_network_management_get_home_id_IgnoreAndReturn(home_id); + zpc_attribute_store_test_helper_create_network(); + + // Unset previous definition get/set functions + for (auto &r: resolver_functions) { + r.second = NULL; + } + + memset(received_frame, 0, sizeof(received_frame)); + received_frame_size = 0; + // Unset previous definition of handler + memset(&handler, 0, sizeof(zwave_command_handler_t)); + + // Resolution functions + attribute_resolver_register_rule_Stub(&attribute_resolver_register_rule_stub); + + // Handler registration + zwave_command_handler_register_handler_Stub( + &zwave_command_handler_register_handler_stub); + // Call init + TEST_ASSERT_EQUAL(SL_STATUS_OK, zwave_command_class_user_credential_init()); +} + +/// Called after each and every test +void tearDown() {} + +//////////////////////////////////////////////////////////////////////////// +// User Capabilities Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_user_capabilities_get_happy_case() +{ + helper_test_get_no_args_happy_case(USER_CAPABILITIES_GET); +} + +void test_user_credential_user_capabilities_report_happy_case() +{ + uint16_t number_of_users; + user_credential_supported_credential_rules_t cred_rule_bitmask; + uint8_t username_max_length; + uint8_t support_user_schedule; + uint8_t support_all_users_checksum; + uint8_t support_user_checksum; + uint8_t supported_user_types_bitmask_length; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask; + + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + // Test reported values based on the variables in this function + auto test_reported_values = [&]() { + // Create frame object + std::vector report_frame = { + COMMAND_CLASS_USER_CREDENTIAL, + USER_CAPABILITIES_REPORT, + (uint8_t)((number_of_users & 0xFF00) >> 8), // MSB + (uint8_t)(number_of_users & 0x00FF), // LSB + cred_rule_bitmask, + username_max_length, + (uint8_t)((support_user_schedule << 7) | (support_all_users_checksum << 6) + | (support_user_checksum << 5)), + supported_user_types_bitmask_length}; + + // Add bitmask value + for (uint8_t i = 0; i < supported_user_types_bitmask_length; i++) { + uint8_t offset = i; + uint8_t shift = 8 * offset; + uint32_t bitmask = 0xFF << shift; + + uint8_t value_8bit = (supported_user_types_bitmask & bitmask) >> shift; + report_frame.push_back(value_8bit); + } + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); + + // Define data structures + std::map uint8_attribute_map = { + {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), cred_rule_bitmask}, + {ATTRIBUTE(MAX_USERNAME_LENGTH), username_max_length}, + {ATTRIBUTE(SUPPORT_USER_SCHEDULE), support_user_schedule}, + {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), support_all_users_checksum}, + {ATTRIBUTE(SUPPORT_USER_CHECKSUM), support_user_checksum}, + }; + + std::map uint16_attribute_map = { + {ATTRIBUTE(NUMBER_OF_USERS), number_of_users}, + }; + std::map uint32_attribute_map = { + {ATTRIBUTE(SUPPORTED_USER_TYPES), supported_user_types_bitmask}, + }; + + // Test values + helper_test_attribute_store_values(uint8_attribute_map); + helper_test_attribute_store_values(uint16_attribute_map); + helper_test_attribute_store_values(uint32_attribute_map); + + attribute_store_node_t all_user_checksum_node + = attribute_store_get_node_child_by_type(endpoint_id_node, + ATTRIBUTE(ALL_USERS_CHECKSUM), + 0); + if (support_all_users_checksum) { + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + all_user_checksum_node, + "ALL_USERS_CHECKSUM node should exists " + "since all_user_checksum_node == true"); + } else { + TEST_ASSERT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + all_user_checksum_node, + "ALL_USERS_CHECKSUM node should NOT exists " + "since all_user_checksum_node == false"); + } + + // Remove node for next tests cases + attribute_store_delete_node(all_user_checksum_node); + }; + + printf("Test with first set of data\n"); + number_of_users = 1212; + cred_rule_bitmask = 0b00000111; + username_max_length = 12; + support_user_schedule = 1; + support_all_users_checksum = 1; + support_user_checksum = 1; + supported_user_types_bitmask_length = 2; + supported_user_types_bitmask = 0b111111111; + // Do the testing + test_reported_values(); + + printf("Test with second set of data\n"); + number_of_users = 1313; + cred_rule_bitmask = 0b00011111; + username_max_length = 21; + support_user_schedule = 0; + support_all_users_checksum = 0; + support_user_checksum = 0; + supported_user_types_bitmask_length = 4; + supported_user_types_bitmask = 0xFFFFFFFF; + // Do the testing + test_reported_values(); +} + +//////////////////////////////////////////////////////////////////////////// +// Credential Capabilities Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_credential_capabilities_get_happy_case() +{ + helper_test_get_no_args_happy_case(CREDENTIAL_CAPABILITIES_GET); +} + +void test_user_credential_credential_capabilities_report_happy_case() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + auto create_report_frame + = [&](uint8_t credential_checksum_support, + std::vector credential_type, + std::vector cl_support, + std::vector supported_credential_slots, + std::vector min_length, + std::vector max_length) { + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, + CREDENTIAL_CAPABILITIES_REPORT, + (uint8_t)(credential_checksum_support << 7), + (uint8_t)credential_type.size()}; + + auto push_uint16 = [&](std::vector vector) { + for (auto &v: vector) { + report_frame.push_back((uint8_t)((v & 0xFF00) >> 8)); + report_frame.push_back((uint8_t)(v & 0x00FF)); + } + }; + + for (auto &c: credential_type) { + report_frame.push_back(c); + } + + for (auto &cl: cl_support) { + report_frame.push_back((uint8_t)(cl << 7)); + } + + push_uint16(supported_credential_slots); + push_uint16(min_length); + push_uint16(max_length); + + return report_frame; + }; + + uint8_t credential_checksum_support = 1; + std::vector credential_type = {1, 3, 4, 5}; + std::vector cl_support = {1, 0, 0, 1}; + std::vector supported_credential_slots = {1233, 11233, 21233, 33}; + std::vector min_length = {2, 2362, 255, 1255}; + std::vector max_length = {5632, 15632, 25632, 32568}; + + auto test_report_values = [&]() { + uint8_t reported_credential_checksum_support; + attribute_store_node_t support_node + = attribute_store_get_first_child_by_type( + endpoint_id_node, + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM)); + + TEST_ASSERT_NOT_EQUAL_MESSAGE( + ATTRIBUTE_STORE_INVALID_NODE, + support_node, + "credential checksum support node should be defined"); + + attribute_store_get_reported(support_node, + &reported_credential_checksum_support, + sizeof(reported_credential_checksum_support)); + + TEST_ASSERT_EQUAL_MESSAGE(credential_checksum_support, + reported_credential_checksum_support, + "Incorrect reported credential checksum support"); + + for (uint8_t i = 0; i < credential_type.size(); i++) { + printf("Testing credential batch %d\n", i); + + attribute_store_node_t type_node = attribute_store_get_node_child_by_type( + endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + i); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + type_node, + "Credential type node should be defined"); + user_credential_type_t reported_credential; + + attribute_store_get_reported(type_node, + &reported_credential, + sizeof(reported_credential)); + + TEST_ASSERT_EQUAL_MESSAGE(credential_type[i], + reported_credential, + "Incorrect credential type"); + + std::map uint8_attribute_map = { + {ATTRIBUTE(CREDENTIAL_LEARN_READ_BACK_SUPPORT), cl_support[i]}, + }; + + std::map uint16_attribute_map = { + {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), + supported_credential_slots[i]}, + {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), min_length[i]}, + {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), max_length[i]}, + }; + helper_test_attribute_store_values(uint8_attribute_map, type_node); + helper_test_attribute_store_values(uint16_attribute_map, type_node); + } + }; + + printf("Test with first set of data\n"); + auto report_frame = create_report_frame(credential_checksum_support, + credential_type, + cl_support, + supported_credential_slots, + min_length, + max_length); + + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); + + test_report_values(); + + printf("Test with second set of data\n"); + credential_checksum_support = 0; + credential_type = {6, 7, 8}; + cl_support = {0, 1, 1}; + supported_credential_slots = {15, 1565, 153}; + min_length = {155, 15, 5}; + max_length = {1111, 111, 11}; + report_frame = create_report_frame(credential_checksum_support, + credential_type, + cl_support, + supported_credential_slots, + min_length, + max_length); + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); + + test_report_values(); +} + +//////////////////////////////////////////////////////////////////////////// +// All User Checksum Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_all_users_checksum_get_happy_case() +{ + helper_test_get_no_args_happy_case(ALL_USERS_CHECKSUM_GET); +} + +void test_user_credential_all_users_checksum_report_happy_case() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + auto create_report_frame + = [&](user_credential_all_users_checksum_t checksum) { + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, ALL_USERS_CHECKSUM_REPORT}; + + auto exploded_checksum = explode_uint16(checksum); + + report_frame.push_back(exploded_checksum.msb); + report_frame.push_back(exploded_checksum.lsb); + + return report_frame; + }; + + user_credential_all_users_checksum_t expected_checksum = 0xABCD; + + auto report_frame = create_report_frame(expected_checksum); + + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); + + std::map uint16_attribute_map + = {{ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum}}; + helper_test_attribute_store_values(uint16_attribute_map); +} + +//////////////////////////////////////////////////////////////////////////// +// User Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_user_get_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + auto user_node = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + helper_test_set_get_with_args(USER_GET, + user_node, + {{user_node, DESIRED_ATTRIBUTE}}); +} + +void test_user_credential_user_get_not_found() +{ + helper_test_get_with_args(USER_GET, ATTRIBUTE_STORE_INVALID_NODE); +} + +std::vector helper_create_user_report_frame( + user_credential_user_unique_id_t next_user_id, + user_credential_user_modifier_type_t user_modifier_type, + user_credential_user_modifier_node_id_t user_modifier_node_id, + user_credential_user_unique_id_t user_id, + user_credential_user_type_t user_type, + uint8_t user_active_state, + user_credential_supported_credential_rules_t credential_rule, + user_credential_expiring_timeout_minutes_t expiring_timeout_minutes, + user_credential_user_name_encoding_t user_name_encoding, + std::string user_name) +{ + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, USER_REPORT}; + + auto exploded_next_user_id = explode_uint16(next_user_id); + report_frame.push_back(exploded_next_user_id.msb); + report_frame.push_back(exploded_next_user_id.lsb); + + report_frame.push_back(user_modifier_type); + + auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); + report_frame.push_back(exploded_user_modifier_node_id.msb); + report_frame.push_back(exploded_user_modifier_node_id.lsb); + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(user_type); + report_frame.push_back(user_active_state); + report_frame.push_back(credential_rule); + + auto exploded_time = explode_uint16(expiring_timeout_minutes); + report_frame.push_back(exploded_time.msb); + report_frame.push_back(exploded_time.lsb); + + report_frame.push_back(user_name_encoding); + report_frame.push_back(user_name.size()); + for (char c: user_name) { + report_frame.push_back(c); + } + return report_frame; +}; + +void test_user_credential_user_report_happy_case() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + auto user_get = resolver_functions[USER_GET]; + TEST_ASSERT_NOT_NULL_MESSAGE(user_get, "User get function should be defined"); + + constexpr user_credential_user_unique_id_t EXPECTED_FIRST_USER_ID = 12; + constexpr user_credential_user_unique_id_t EXPECTED_SECOND_USER_ID = 1212; + + user_credential_user_unique_id_t next_user_id = EXPECTED_SECOND_USER_ID; + user_credential_user_modifier_type_t user_modifier_type = 2; + user_credential_user_modifier_node_id_t user_modifier_node_id = 1313; + user_credential_user_unique_id_t user_id = EXPECTED_FIRST_USER_ID; + user_credential_user_type_t user_type = 3; + user_credential_user_active_state_t user_active_state = 1; + user_credential_supported_credential_rules_t credential_rule = 2; + user_credential_expiring_timeout_minutes_t expiring_timeout_minutes = 1515; + user_credential_user_name_encoding_t user_name_encoding = 0; + std::string user_name = "DoUzE"; + + auto test_user_values = [&](attribute_store_node_t user_node) { + // Check main node value + user_credential_user_unique_id_t reported_id; + attribute_store_get_reported(user_node, &reported_id, sizeof(reported_id)); + TEST_ASSERT_EQUAL_MESSAGE(user_id, + reported_id, + "User Unique ID is incorrect"); + // Then test values underneath + std::map uint8_attribute_map + = {{ATTRIBUTE(USER_MODIFIER_TYPE), user_modifier_type}, + {ATTRIBUTE(USER_TYPE), user_type}, + {ATTRIBUTE(USER_ACTIVE_STATE), user_active_state}, + {ATTRIBUTE(CREDENTIAL_RULE), credential_rule}}; + helper_test_attribute_store_values(uint8_attribute_map, user_node); + + std::map uint16_attribute_map + = {{ATTRIBUTE(USER_MODIFIER_NODE_ID), user_modifier_node_id}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), expiring_timeout_minutes}}; + helper_test_attribute_store_values(uint16_attribute_map, user_node); + + helper_test_string_value({{ATTRIBUTE(USER_NAME), user_name}}, user_node); + + // Check user credential desired values + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 12; + auto credential_type_node + = attribute_store_get_node_child_by_type(user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + 0); + attribute_store_get_reported(credential_type_node, + &credential_type, + sizeof(credential_type)); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + credential_type_node, + "credential_type_node should exist"); + + auto credential_slot_node + = attribute_store_get_node_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + 0); + attribute_store_get_desired(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + credential_slot_node, + "credential_slot_node should exist"); + + TEST_ASSERT_EQUAL_MESSAGE( + 0, + credential_type, + "Credential Type should be at 0 and should exists"); + TEST_ASSERT_EQUAL_MESSAGE( + 0, + credential_slot, + "Credential Slot should be at 0 and should exists"); + }; // end test_user_values lambda + + auto report_frame = helper_create_user_report_frame(next_user_id, + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout_minutes, + user_name_encoding, + user_name); + + printf("First user creation\n"); + + // Create first user + auto first_user_id_node + = attribute_store_add_node(ATTRIBUTE(USER_UNIQUE_ID), endpoint_id_node); + // First user should have ID 0 and then set in the report + user_credential_user_unique_id_t first_id = 0; + attribute_store_set_desired(first_user_id_node, &first_id, sizeof(first_id)); + + // Simulate get on that user + sl_status_t user_get_status + = user_get(first_user_id_node, received_frame, &received_frame_size); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + user_get_status, + "User get should have returned SL_STATUS_OK"); + + // Call report + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "User Report should have returned SL_STATUS_OK"); + // Test values + test_user_values(first_user_id_node); + + // Test structure + auto user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(2, + user_id_count, + "User node count mismatch. Should be 2 : 1 for " + "the reported one and 1 for the next one"); + auto second_user_id_node + = attribute_store_get_node_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + 1); + + printf("Second and last user creation\n"); + + // Simulate a node with desired value of 0 to see if it is properly removed + // to prevent infinite loop + user_credential_user_unique_id_t id_zero = 0; + attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &id_zero, + sizeof(id_zero)); + + // Check second & not defined user id + user_credential_user_unique_id_t second_user_id; + attribute_store_get_desired(second_user_id_node, + &second_user_id, + sizeof(second_user_id)); + TEST_ASSERT_EQUAL_MESSAGE( + next_user_id, + second_user_id, + "Second user id should have it's desired value defined"); + + // Simulate a GET on that user + // Removes the desired state and sets to reported instead + user_get_status + = user_get(second_user_id_node, received_frame, &received_frame_size); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + user_get_status, + "User get should have returned SL_STATUS_OK"); + + // Second and last user + next_user_id = 0; + user_modifier_type = 3; + user_modifier_node_id = 1414; + user_id = EXPECTED_SECOND_USER_ID; + user_type = 5; + user_active_state = 0; + credential_rule = 1; + user_name_encoding = 1; + user_name = "NoDoUzE4YoU"; + + report_frame = helper_create_user_report_frame(next_user_id, + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout_minutes, + user_name_encoding, + user_name); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Second User Report should have returned SL_STATUS_OK"); + // Test values + test_user_values(second_user_id_node); + + // Test structure + + // The report function should not have created an other user unique id node (next_user_id = 0) + user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(2, + user_id_count, + "User node count mismatch. Should be 2 : 1 for " + "the reported one and 1 for the next one"); + + user_credential_user_unique_id_t reported_id; + attribute_store_get_reported(first_user_id_node, + &reported_id, + sizeof(reported_id)); + TEST_ASSERT_EQUAL_MESSAGE(EXPECTED_FIRST_USER_ID, + reported_id, + "First user id mismatch"); + attribute_store_get_reported(second_user_id_node, + &reported_id, + sizeof(reported_id)); + TEST_ASSERT_EQUAL_MESSAGE(EXPECTED_SECOND_USER_ID, + reported_id, + "Second user id mismatch"); +} + +void test_user_credential_user_report_user_not_found() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + auto report_frame + = helper_create_user_report_frame(0, 0, 0, 12, 0, 0, 0, 0, 0, "^^"); + + // Not found since we haven't created any user_unique_id + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_NOT_SUPPORTED, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "User Report should have returned SL_STATUS_NOT_SUPPORTED"); + + // Check that no user_unique_id node has been created + auto user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(0, + user_id_count, + "No user_unique_id node should be created"); +} + +void test_user_credential_user_report_user_with_id0() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + auto report_frame + = helper_create_user_report_frame(0, 0, 0, 0, 0, 0, 0, 0, 0, "DOUZE"); + + // Create user id with reported ID of 0 to simulate user get of id 0 + user_credential_user_unique_id_t user_id = 0; + attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Not found since we haven't created any user_unique_id + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "User Report should have returned SL_STATUS_OK and ignore the frame"); + + // Check that no user_unique_id node has been created (and the invalid node was deleted) + auto user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(0, + user_id_count, + "No user_unique_id node should be created"); +} + +void test_user_credential_user_report_user_deleted() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + // Create user id with reported ID of 0 to simulate user get of id 0 + user_credential_user_unique_id_t user_id = 12; + auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + user_id_node, + "User ID node should be created"); + + auto user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(1, user_id_count, "Should have one user by now"); + + auto report_frame = helper_create_user_report_frame(user_id, + USER_REPORT_DNE, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + "????"); + + // Should delete this user + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "User Report should have returned SL_STATUS_NOT_SUPPORTED"); + + user_id_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(1, + user_id_count, + "Should not have any user by now"); +} + +//////////////////////////////////////////////////////////////////////////// +// Credential Get/Report +//////////////////////////////////////////////////////////////////////////// + +void test_user_credential_credential_get_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + auto user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + user_credential_type_t credential_type = 2; + auto credential_type_node + = attribute_store_emplace_desired(user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + user_credential_slot_t credential_slot = 1212; + auto credential_slot_node + = attribute_store_emplace_desired(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + // Get should make both credential_type_node and credential_slot_node reported value as the desired values + helper_test_set_get_with_args(CREDENTIAL_GET, + credential_slot_node, + { + {user_node, REPORTED_ATTRIBUTE}, + {credential_type_node, REPORTED_ATTRIBUTE}, + {credential_slot_node, DESIRED_ATTRIBUTE}, + }); +} + +void test_user_credential_credential_get_no_credential_type() +{ + helper_test_get_with_args(CREDENTIAL_GET, ATTRIBUTE_STORE_INVALID_NODE); +} + +std::vector helper_create_credential_report_frame( + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + uint8_t crb, + std::vector credential_data, + user_credential_user_modifier_type_t credential_modifier_type, + user_credential_user_modifier_node_id_t credential_modifier_node_id, + user_credential_type_t next_credential_type, + user_credential_slot_t next_credential_slot) +{ + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_REPORT}; + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(credential_type); + + auto exploded_credential_slot = explode_uint16(credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(crb << 7); + report_frame.push_back(credential_data.size()); + + for (uint8_t credential_value: credential_data) { + report_frame.push_back(credential_value); + } + + report_frame.push_back(credential_modifier_type); + auto exploded_credential_modifier_node_id + = explode_uint16(credential_modifier_node_id); + report_frame.push_back(exploded_credential_modifier_node_id.msb); + report_frame.push_back(exploded_credential_modifier_node_id.lsb); + + report_frame.push_back(next_credential_type); + auto exploded_next_credential_slot = explode_uint16(next_credential_slot); + report_frame.push_back(exploded_next_credential_slot.msb); + report_frame.push_back(exploded_next_credential_slot.lsb); + + return report_frame; +}; + +void test_user_credential_credential_report_no_credential() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + user_credential_user_unique_id_t user_id = 12; + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + user_id_node, + "User ID node should be defined"); + + auto report_frame + = helper_create_credential_report_frame(user_id, 0, 0, 0, {}, 0, 0, 0, 0); + + // SHould return ok since credential_type and credential node is 0 + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); +} + +void test_user_credential_credential_report_missing_user() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + auto report_frame + = helper_create_credential_report_frame(12, 1, 1, 0, {}, 0, 0, 0, 0); + + // Not found since we haven't created any user_unique_id + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_NOT_SUPPORTED, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); +} + +void test_user_credential_credential_report_missing_credential_type() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + user_credential_user_unique_id_t user_id = 12; + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + user_id_node, + "User ID node should be defined"); + + auto report_frame + = helper_create_credential_report_frame(user_id, 1, 5, 0, {}, 0, 0, 0, 0); + + // Not found since we haven't created any credential_type + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_NOT_SUPPORTED, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); +} + +void test_user_credential_credential_report_missing_credential_slot() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + user_credential_user_unique_id_t user_id = 12; + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + user_id_node, + "User ID node should be defined"); + user_credential_type_t credential_type = 121; + auto credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + credential_type_node, + "Credential type node should be defined"); + + auto report_frame = helper_create_credential_report_frame(user_id, + credential_type, + 1212, + 0, + {}, + 0, + 0, + 0, + 0); + + // Not found since we haven't created any credential_slot + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_NOT_SUPPORTED, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); +} + +void test_user_credential_credential_report_happy_case() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + auto credential_get = resolver_functions[CREDENTIAL_GET]; + TEST_ASSERT_NOT_NULL_MESSAGE(credential_get, + "Credential get function should be defined"); + + user_credential_user_unique_id_t user_id = 122; + user_credential_type_t credential_type = 12; + user_credential_slot_t credential_slot = 1212; + uint8_t crb = 1; + std::vector credential_data = {12, 13, 14, 15, 16}; + user_credential_user_modifier_type_t credential_modifier_type = 13; + user_credential_user_modifier_node_id_t credential_modifier_node_id = 1312; + user_credential_type_t next_credential_type = 12; + user_credential_slot_t next_credential_slot = 1; + + auto test_user_values = [&](attribute_store_node_t credential_type_node, + attribute_store_node_t credential_slot_node) { + // Check main node value + user_credential_type_t reported_cred_type; + attribute_store_get_reported(credential_type_node, + &reported_cred_type, + sizeof(reported_cred_type)); + TEST_ASSERT_EQUAL_MESSAGE(credential_type, + reported_cred_type, + "Credential type value mismatch"); + + user_credential_slot_t reported_cred_slot; + attribute_store_get_reported(credential_slot_node, + &reported_cred_slot, + sizeof(reported_cred_slot)); + TEST_ASSERT_EQUAL_MESSAGE(credential_slot, + reported_cred_slot, + "Credential slot value mismatch"); + + // Then test values underneath + std::map uint8_attribute_map + = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}, + {ATTRIBUTE(CREDENTIAL_READ_BACK), crb}}; + helper_test_attribute_store_values(uint8_attribute_map, + credential_slot_node); + + std::map uint16_attribute_map + = {{ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), credential_modifier_node_id}}; + helper_test_attribute_store_values(uint16_attribute_map, + credential_slot_node); + + auto credential_length_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + uint8_t reported_credential_length; + attribute_store_get_reported(credential_length_node, + &reported_credential_length, + sizeof(reported_credential_length)); + TEST_ASSERT_EQUAL_MESSAGE(credential_data.size(), + reported_credential_length, + "Credential data length value mismatch"); + + std::vector reported_credential_data; + reported_credential_data.resize(reported_credential_length); + + attribute_store_get_child_reported(credential_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + reported_credential_data.data(), + reported_credential_length); + + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(credential_data.data(), + reported_credential_data.data(), + credential_data.size(), + "Credential data mismatch"); + }; // end test_user_values lambda + + auto check_credentials_node_count = + [](attribute_store_node_t user_id_node, + size_t expected_credential_type_count, + size_t expected_credential_slot_count) { + auto count_credential_type = attribute_store_get_node_child_count_by_type( + user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + TEST_ASSERT_EQUAL_MESSAGE(expected_credential_type_count, + count_credential_type, + "Incorrect credential type count"); + + size_t count_credential_slot = 0; + for (size_t i = 0; i < count_credential_type; i++) { + auto credential_type_node + = attribute_store_get_node_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + i); + count_credential_slot += attribute_store_get_node_child_count_by_type( + credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + } + + TEST_ASSERT_EQUAL_MESSAGE(expected_credential_slot_count, + count_credential_slot, + "Incorrect credential slot count"); + }; + + auto check_next_credential_node_value + = [&](attribute_store_node_t next_credential_type_node, + attribute_store_node_t next_credential_slot_node) { + // First check node existence + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + next_credential_type_node, + "next_credential_type_node should exist"); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + next_credential_slot_node, + "next_credential_slot_node should exist"); + + user_credential_type_t reported_next_credential_type = 0; + user_credential_slot_t reported_next_credential_slot = 0; + + attribute_store_read_value(next_credential_type_node, + REPORTED_ATTRIBUTE, + &reported_next_credential_type, + sizeof(reported_next_credential_type)); + + attribute_store_read_value(next_credential_slot_node, + DESIRED_ATTRIBUTE, + &reported_next_credential_slot, + sizeof(reported_next_credential_slot)); + + TEST_ASSERT_EQUAL_MESSAGE(next_credential_type, + reported_next_credential_type, + "Next Credential Type value mismatch"); + TEST_ASSERT_EQUAL_MESSAGE(next_credential_slot, + reported_next_credential_slot, + "Next Credential Slot value mismatch"); + }; + + //>>>> First credential + printf("First credential creation\n"); + + auto report_frame + = helper_create_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + + // Create first credential + auto nodes + = helper_create_credential_structure(user_id, 0, 0, DESIRED_ATTRIBUTE); + + auto user_id_node = nodes.user_id_node; + auto first_credential_type_node = nodes.credential_type_node; + auto first_credential_slot_node = nodes.credential_slot_node; + + attribute_store_log(); + + // Simulate get on that credential + sl_status_t credential_get_status = credential_get(first_credential_slot_node, + received_frame, + &received_frame_size); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + credential_get_status, + "First Credential get should have returned SL_STATUS_OK"); + + // Call report + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "First Credential Report should have returned SL_STATUS_OK"); + // Test values + test_user_values(first_credential_type_node, first_credential_slot_node); + // We should have 1 credential type and 2 credential slot + check_credentials_node_count(user_id_node, 1, 2); + + // Test if next credentials are well defined + auto second_credential_slot_node + = attribute_store_get_node_child_by_type(first_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + 1); + check_next_credential_node_value(first_credential_type_node, + second_credential_slot_node); + + //>>>> Second credential + printf("Second credential creation\n"); + + credential_type = next_credential_type; + credential_slot = next_credential_slot; + crb = 0; + credential_data = {1, 2}; + credential_modifier_type = 3; + credential_modifier_node_id = 13121; + next_credential_type = 121; + next_credential_slot = 3; + + report_frame + = helper_create_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + + // Simulate get on that credential + credential_get_status = credential_get(second_credential_slot_node, + received_frame, + &received_frame_size); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + credential_get_status, + "Credential get should have returned SL_STATUS_OK"); + + // Call report + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Second Credential Report should have returned SL_STATUS_OK"); + // Test values + test_user_values(first_credential_type_node, second_credential_slot_node); + // We should have 2 credential type and 2 credential slot + check_credentials_node_count(user_id_node, 2, 3); + + auto second_credential_type_node + = attribute_store_get_node_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + 1); + auto third_credential_slot_node + = attribute_store_get_node_child_by_type(second_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + 0); + + // New nodes so we check their desired values + check_next_credential_node_value(second_credential_type_node, + third_credential_slot_node); + + //>>>> Third credential + printf("Third and last credential creation\n"); + credential_type = next_credential_type; + credential_slot = next_credential_slot; + crb = 1; + credential_data = {15}; + credential_modifier_type = 2; + credential_modifier_node_id = 12; + next_credential_type = 0; + next_credential_slot = 0; + // TODO : check if we need helper_check_reported_but_no_desired_attribute + report_frame + = helper_create_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + + // Simulate get on that credential + credential_get_status = credential_get(third_credential_slot_node, + received_frame, + &received_frame_size); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + credential_get_status, + "Credential get should have returned SL_STATUS_OK"); + + // Call report + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size()), + "Second Credential Report should have returned SL_STATUS_OK"); + // Test values + test_user_values(second_credential_type_node, third_credential_slot_node); + // We should still have 2 credential type and 3 credential slots since it was the last credential + check_credentials_node_count(user_id_node, 2, 3); +} + +//////////////////////////////////////////////////////////////////////////// +// Attribute creation +//////////////////////////////////////////////////////////////////////////// +void test_attribute_creation_happy_case() +{ + zwave_cc_version_t version = 1; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + std::vector created_types = { + ATTRIBUTE(NUMBER_OF_USERS), + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + }; + + for (auto &type: created_types) { + const std::string error_msg + = "Attribute " + std::string(attribute_store_get_type_name(type)) + + " should exist"; + + TEST_ASSERT_NOT_EQUAL_MESSAGE( + ATTRIBUTE_STORE_INVALID_NODE, + attribute_store_get_node_child_by_type(endpoint_id_node, type, 0), + error_msg.c_str()); + } +} + +void test_attribute_creation_no_version() +{ + zwave_cc_version_t version = 0; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + std::vector created_types = { + ATTRIBUTE(NUMBER_OF_USERS), + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + }; + + for (auto &type: created_types) { + const std::string error_msg + = "Attribute " + std::string(attribute_store_get_type_name(type)) + + " should NOT exist"; + + TEST_ASSERT_EQUAL_MESSAGE( + ATTRIBUTE_STORE_INVALID_NODE, + attribute_store_get_node_child_by_type(endpoint_id_node, type, 0), + error_msg.c_str()); + } +} + +void test_post_interview_discovery() +{ + // Lambdas + auto count_user_node = [](size_t expected_value) { + auto user_id_node_count + = attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + TEST_ASSERT_EQUAL_MESSAGE(expected_value, + user_id_node_count, + "User ID node count mismatch"); + }; + + // Test logic + + NodeStateNetworkStatus network_status = ZCL_NODE_STATE_NETWORK_STATUS_OFFLINE; + auto network_status_node + = attribute_store_emplace(node_id_node, + DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS, + &network_status, + sizeof(network_status)); + + count_user_node(0); + + // Interview state + network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_INTERVIEWING; + attribute_store_set_reported(network_status_node, + &network_status, + sizeof(network_status)); + + count_user_node(0); + + // Simulate one more endpoint and only add nif to one of them + + // Add NIF to our endpoint to tell that we support User Credential + std::vector nif_value = {COMMAND_CLASS_USER_CREDENTIAL}; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE_ZWAVE_SECURE_NIF, + nif_value.data(), + nif_value.size()); + + // Add another endpoint without User Credential support + zwave_endpoint_id_t endpoint_id_2 = endpoint_id + 12; + attribute_store_emplace(node_id_node, + ATTRIBUTE_ENDPOINT_ID, + &endpoint_id_2, + sizeof(endpoint_id_2)); + + // Display current store log for debug purpose + attribute_store_log(); + + // Set two random user id to see if discovery remove it + user_credential_user_unique_id_t user_id = 12; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + user_id = 1222; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set the network status to online + network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; + attribute_store_set_reported(network_status_node, + &network_status, + sizeof(network_status)); + + // Now we check attribute store + auto user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + attribute_store_get_desired(user_id_node, &user_id, sizeof(user_id)); + TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + user_id_node, + "User id node should exists"); + TEST_ASSERT_EQUAL_MESSAGE(0, user_id, "User ID desired value should be 0"); + count_user_node(1); +} + +} // extern "C" \ No newline at end of file From 898876504267138009746f4db43a0a427cb10ea6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 17 Apr 2024 11:39:51 +0200 Subject: [PATCH 03/60] UIC-3222: Credential Set UIC-3222: Credential Set on Credential Operation Type UIC-3222: Set Credential (delete) improvement UIC-3222: Credential SET also look in desired values UIC-3222: Fix delete operation on Credential SET UIC-3222: Allow extra bytes when testing set/get commands --- .../attribute_store_defined_attribute_types.h | 92 ++++++ ...wave_command_class_user_credential_types.h | 3 + .../zpc_attribute_store_type_registration.cpp | 53 ++++ .../zwave_command_classes/CMakeLists.txt | 1 + .../zwave_command_class_user_credential.cpp | 253 ++++++++++++++++- .../src/zwave_command_classes_fixt.c | 2 + .../zwave_command_classes/test/CMakeLists.txt | 18 +- ...ave_command_class_user_credential_test.cpp | 263 ++++++++++++++---- 8 files changed, 628 insertions(+), 57 deletions(-) diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 8d5e36adb..b79c8926b 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1113,6 +1113,98 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_SOUND_SWITCH_TONE_INFO_NAME, DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_SOUND_SWITCH_TONE_PLAY, ((COMMAND_CLASS_SOUND_SWITCH << 8) | 0x08)) + +///////////////////////////////////////////////// +// User Credential Command Class +///< This represents the version of the User CredentialCommand class. +/// zwave_cc_version_t +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_VERSION, + ZWAVE_CC_VERSION_ATTRIBUTE(COMMAND_CLASS_USER_CREDENTIAL)) + + +/// > User Capabilities +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_NUMBER_OF_USERS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x02)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x03)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_MAX_USERNAME_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x04)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_USER_SCHEDULE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x05)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ALL_USERS_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x06)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_USER_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x07)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_USER_TYPES, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x08)) + +/// > Credential Capabilities +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x09)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_SUPPORT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0B)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0C)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0D)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0F)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x10)) + +/// > All Users Checksum +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ALL_USERS_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x11)) + +/// > Users +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x12)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x13)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_NODE_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x14)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x15)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_ACTIVE_STATE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x16)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x17)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME_ENCODING, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x18)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x19)) + +/// > Credentials +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) + + +// Specific to Credential SET +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_OPERATION_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x21)) + +// Specific to USER SET +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x22)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) + ///////////////////////////////////////////////// // Z-Wave Plus Info CC DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_ZWAVEPLUS_INFO_VERSION, diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index e6e29800f..db365aa97 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -51,6 +51,9 @@ typedef uint16_t user_credential_slot_t; ///> Operation type. uint8_t typedef uint8_t user_credential_operation_type_t; +///> Operation type. uint8_t +typedef uint8_t user_credential_operation_type_t; + #ifdef __cplusplus extern "C" { #endif diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index 574642769..9d5c2144b 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -454,6 +454,59 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CODE_SUPPORTED_KEYS, "Supported Keys bitmask", ATTRIBUTE_COMMAND_CLASS_USER_CODE_CAPABILITIES, BYTE_ARRAY_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CODE_CHECKSUM, "User Code Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CODE_DATA, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CODE_KEYPAD_MODE, "Keypad Mode", ATTRIBUTE_COMMAND_CLASS_USER_CODE_DATA, U8_STORAGE_TYPE}, + + + ///////////////////////////////////////////////////////////////////// + // User Credential Command Class attributes + ///////////////////////////////////////////////////////////////////// + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_VERSION, "User Credential Version", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + + // User capabilities + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_NUMBER_OF_USERS, "User Credential User Count", ATTRIBUTE_ENDPOINT_ID, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES, "User Credential Supported Rules", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_MAX_USERNAME_LENGTH, "User Credential Max Username Length", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_USER_SCHEDULE, "User Credential Support User Schedule", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ALL_USERS_CHECKSUM, "User Credential Support All User Checksum", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_USER_CHECKSUM, "User Credential Support By User Checksum", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_USER_TYPES, "User Credential Supported User types", ATTRIBUTE_ENDPOINT_ID, U32_STORAGE_TYPE}, + + // Credential capabilities + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, "User Credential Support Credential Checksum", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, "User Credential Supported Credential Type", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_SUPPORT, "User Credential Learn Support", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, "User Credential Supported Slot Count", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, "User Credential Min Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, "User Credential Max Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, "User Credential Learn Recommended Timeout", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, "User Credential Learn Number Of Steps", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, + + + // All Users Checksum + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ALL_USERS_CHECKSUM, "User Credential All User Checksum", ATTRIBUTE_ENDPOINT_ID, U16_STORAGE_TYPE}, + + // User + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, "User Credential User Unique Identifier", ATTRIBUTE_ENDPOINT_ID, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_TYPE, "User Credential User Modifier Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_NODE_ID, "User Credential User Modifier Node ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_TYPE, "User Credential User Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_ACTIVE_STATE, "User Credential User Active State", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME, "User Credential User Name", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, C_STRING_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME_ENCODING, "User Credential User Name Encoding", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, "User Credential User Credential Rule", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, "User Credential User Operation type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, "User Credential User Expiring Timeout Minutes", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U16_STORAGE_TYPE}, + + // Credential + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, "User Credential Credential Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, "User Credential Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, "User Credential Credential Data Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, "User Credential Credential Data", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, BYTE_ARRAY_STORAGE_TYPE}, + + + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, "User Credential Credential Read Back Flag", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, "User Credential Credential Modifier type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, "User Credential Credential Node ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, + ///////////////////////////////////////////////////////////////////// // Z-Wave Plus Info Command Class attributes ///////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/CMakeLists.txt index 99c75db5f..b5d545e0e 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -56,6 +56,7 @@ add_library( src/zwave_command_class_time_parameters.cpp src/zwave_command_class_time.c src/zwave_command_class_user_code.c + src/zwave_command_class_user_credential.cpp src/zwave_command_class_version.c src/zwave_command_class_wake_up.c src/zwave_command_class_zwave_plus_info.c diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index af09fceb3..dc232a6bc 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -77,6 +77,17 @@ struct user_field_data { uint8_t shift_right = 0; }; +// Used to create command frame +struct attribute_command_data { + // Attribute type that will be fetched from the base_node + attribute_store_type_t attribute_type; + // Attribute value state (reported, desired,...) + attribute_store_node_value_state_t attribute_state; + // If not ATTRIBUTE_STORE_INVALID_NODE, the function will not fetch attribute_type + // but will use this node directly + attribute_store_node_t node = ATTRIBUTE_STORE_INVALID_NODE; +}; + ///////////////////////////////////////////////////////////////////////////// // Type Helpers ///////////////////////////////////////////////////////////////////////////// @@ -311,6 +322,154 @@ sl_status_t return status; } +/** + * @brief Create a command frame (SET or GET) based on the attribute store + * + * @param command Command to send (will be in frame[1], e.g USER_SET) + * @param command_data Attributes that will be in the frame (in order of appearance in the frame) + * @param base_node If not specified otherwise will fetch the attributes that are under this node + * @param frame Frame object from the callback + * @param frame_length Frame size from the callback + * + * @return sl_status_t SL_STATUS_OK if everything was fine + */ +sl_status_t create_command_frame(uint8_t command, + std::vector command_data, + attribute_store_node_t base_node, + uint8_t *frame, + uint16_t *frame_length) +{ + frame[0] = COMMAND_CLASS_USER_CREDENTIAL; + frame[1] = command; + + uint16_t current_index = 2; + + for (auto &attribute_info: command_data) { + auto node_storage_type + = attribute_store_get_storage_type(attribute_info.attribute_type); + auto attribute_description + = attribute_store_get_type_name(attribute_info.attribute_type); + + attribute_store_node_t node; + if (attribute_info.node == ATTRIBUTE_STORE_INVALID_NODE) { + node = attribute_store_get_first_child_by_type( + base_node, + attribute_info.attribute_type); + } else { + node = attribute_info.node; + } + + if (node == ATTRIBUTE_STORE_INVALID_NODE) { + sl_log_critical(LOG_TAG, + "Can't find node for Attribute %s", + attribute_description); + return SL_STATUS_FAIL; + } + + sl_status_t status; + switch (node_storage_type) { + case U8_STORAGE_TYPE: { + uint8_t uint8_value; + status = attribute_store_read_value(node, + attribute_info.attribute_state, + &uint8_value, + sizeof(uint8_value)); + frame[current_index++] = uint8_value; + } break; + case U16_STORAGE_TYPE: { + uint16_t uint16_value; + status = attribute_store_read_value(node, + attribute_info.attribute_state, + &uint16_value, + sizeof(uint16_value)); + auto exploded_uint16 = explode_uint16(uint16_value); + frame[current_index++] = exploded_uint16.msb; + frame[current_index++] = exploded_uint16.lsb; + } break; + // Variable length field + case BYTE_ARRAY_STORAGE_TYPE: { + // First get the length + auto credential_length_node = attribute_store_get_node_parent(node); + + uint8_t credential_data_length = 0; + status = attribute_store_read_value( + credential_length_node, + attribute_info.attribute_state, + &credential_data_length, + sizeof(credential_data_length)); + + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Missing BYTE_ARRAY_STORAGE_TYPE length for attribute %s", + attribute_description); + return SL_STATUS_NOT_SUPPORTED; + } + + frame[current_index++] = credential_data_length; + + // Then the data + std::vector credential_data; + credential_data.resize(credential_data_length); + status = attribute_store_read_value(node, + attribute_info.attribute_state, + credential_data.data(), + credential_data_length); + + for (const uint8_t &cred: credential_data) { + frame[current_index++] = cred; + } + + } break; + + case C_STRING_STORAGE_TYPE: { + char c_user_name[MAX_CHAR_SIZE]; + // Unfortunately attribute_store_get_string is not exposed so we need to do this + switch (attribute_info.attribute_state) { + case DESIRED_OR_REPORTED_ATTRIBUTE: + status + = attribute_store_get_desired_else_reported_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + case DESIRED_ATTRIBUTE: + status = attribute_store_get_desired_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + case REPORTED_ATTRIBUTE: + status = attribute_store_get_reported_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + } + + std::string user_name = c_user_name; + for (const char &c: user_name) { + frame[current_index++] = c; + } + + } break; + default: + sl_log_critical(LOG_TAG, + "Not supported type for %s", + attribute_description); + return SL_STATUS_FAIL; + } + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get value of Attribute %s", + attribute_description); + return SL_STATUS_NOT_SUPPORTED; + } + } + + *frame_length = current_index; + + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -623,7 +782,7 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( } ///////////////////////////////////////////////////////////////////////////// -// Credential Get/Report +// Credential Set/Get/Report ///////////////////////////////////////////////////////////////////////////// // Start credential interview process by starting with 0,0 @@ -669,6 +828,93 @@ void trigger_get_credential(attribute_store_node_t user_unique_id_node, } } +static sl_status_t zwave_command_class_user_credential_credential_set( + attribute_store_node_t credential_operation_type_node, + uint8_t *frame, + uint16_t *frame_length) +{ + // Identifiers nodes + attribute_store_node_t credential_slot_node + = attribute_store_get_first_parent_with_type(credential_operation_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store_node_t credential_type_node + = attribute_store_get_first_parent_with_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + attribute_store_node_t user_unique_id_node + = attribute_store_get_first_parent_with_type(credential_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); + // Since CREDENTIAL_DATA is not directly under credential_slot_node we need to fetch it first + attribute_store_node_t credential_length_node + = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + attribute_store_node_t credential_node + = attribute_store_get_first_child_by_type(credential_length_node, + ATTRIBUTE(CREDENTIAL_DATA)); + // Get operation type + user_credential_operation_type_t operation_type = 0; + sl_status_t status + = attribute_store_get_desired(credential_operation_type_node, + &operation_type, + sizeof(operation_type)); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get operation type. Not sending CREDENTIAL_SET."); + return SL_STATUS_NOT_SUPPORTED; + } + + sl_log_debug(LOG_TAG, + "Credential SET for Credential Slot %d, Credential Type %d, " + "User %d (operation type : %d)", + static_cast( + attribute_store_get_reported_number(credential_slot_node)), + static_cast( + attribute_store_get_reported_number(credential_type_node)), + static_cast( + attribute_store_get_reported_number(user_unique_id_node)), + operation_type); + + // Since the data is not linear we provide the node directly + std::vector set_data + = {{ATTRIBUTE(USER_UNIQUE_ID), + DESIRED_OR_REPORTED_ATTRIBUTE, + user_unique_id_node}, + {ATTRIBUTE(CREDENTIAL_TYPE), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_type_node}, + {ATTRIBUTE(CREDENTIAL_SLOT), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_slot_node}, + {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + DESIRED_ATTRIBUTE, + credential_operation_type_node}}; + + // Add the credential data if we are not trying to remove a credential + if (operation_type != USER_CREDENTIAL_OPERATION_TYPE_DELETE) { + set_data.push_back({ATTRIBUTE(CREDENTIAL_DATA), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_node}); + } + status = create_command_frame(CREDENTIAL_SET, + set_data, + credential_slot_node, + frame, + frame_length); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Can't create Credential SET frame"); + return SL_STATUS_NOT_SUPPORTED; + } + // If we are deleting the credential we are setting 0x00 as a credential length + if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_DELETE) { + frame[*frame_length] = 0x00; + *frame_length += 1; + } + + return SL_STATUS_OK; +} + /** * @brief Credential GET * @@ -1328,6 +1574,11 @@ sl_status_t zwave_command_class_user_credential_init() NULL, &zwave_command_class_user_credential_credential_get); + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_set, + NULL); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_classes_fixt.c b/applications/zpc/components/zwave_command_classes/src/zwave_command_classes_fixt.c index a20c668f3..c776a1cdd 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_classes_fixt.c +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_classes_fixt.c @@ -59,6 +59,7 @@ #include "zwave_command_class_indicator_control.h" #include "zwave_command_class_manufacturer_specific_control.h" #include "zwave_command_class_humidity_control_mode.h" +#include "zwave_command_class_user_credential.h" #include "zwave_command_class_protocol.h" // Generic includes @@ -127,6 +128,7 @@ sl_status_t zwave_command_classes_init() status |= zwave_command_class_time_init(); status |= zwave_command_class_transport_service_init(); status |= zwave_command_class_user_code_init(); + status |= zwave_command_class_user_credential_init(); status |= zwave_command_class_version_init(); status |= zwave_command_class_wake_up_init(); status |= zwave_command_class_zwave_plus_info_init(); diff --git a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt index 9d31a4368..71251b088 100644 --- a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt @@ -150,6 +150,22 @@ target_add_unittest( uic_dotdot_mqtt_mock ) +# User credential test +target_add_unittest( + zwave_command_classes + NAME + zwave_command_class_user_credential_test + SOURCES + zwave_command_class_user_credential_test.cpp + DEPENDS + zpc_attribute_store_test_helper + zwave_controller + zwave_command_handler_mock + uic_attribute_resolver_mock + zpc_attribute_resolver_mock + uic_dotdot_mqtt_mock + zwave_network_management_mock) + # Wake Up Command Class target_add_unittest( zwave_command_classes @@ -857,7 +873,7 @@ target_add_unittest( zpc_attribute_resolver_mock uic_dotdot_mqtt_mock) -# Humidity Control SetPoint test +# CRC16 test target_add_unittest( zwave_command_classes NAME diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 77aecbf84..43f65b4cf 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -58,13 +58,14 @@ struct bound_functions { uint8_t get_func_id; uint8_t set_func_id; }; -static std::map attributes_binding = { - {ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, - {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, - {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, -}; +static std::map attributes_binding + = {{ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, + {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, + {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, + {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}}; // Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on // attributes_binding map. @@ -140,11 +141,11 @@ struct credential_structure_nodes { * @param value_state If DESIRED_ATTRIBUTE : credential_type/credential_slot will have their desired value setup, reported otherwise * @return credential_structure_nodes */ -credential_structure_nodes - helper_create_credential_structure(user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - attribute_store_node_value_state_t value_state = DESIRED_ATTRIBUTE) +credential_structure_nodes helper_create_credential_structure( + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + attribute_store_node_value_state_t value_state = DESIRED_ATTRIBUTE) { credential_structure_nodes nodes; nodes.user_id_node = attribute_store_emplace(endpoint_id_node, @@ -198,29 +199,35 @@ void helper_test_get_no_args_happy_case(uint8_t get_command_id) "Get frame contents mismatch"); } -/// @brief Test given GET function with args -/// Can also test if GET command return SL_STATUS_NOT_SUPPORTED if node == INVALID_STORAGE_TYPE -/// @param get_command_id Get command that should be in resolver_functions -/// @param base_node Base node on which the GET function will be called. If INVALID_STORAGE_TYPE expect the GET function to return SL_STATUS_NOT_SUPPORTED and return. -/// @param nodes Node data that will be used to check and construct the GET frame (order matter since the first one will be the first argument, etc..) -void helper_test_get_with_args( - uint8_t get_command_id, +/** + * @brief Test given SET or GET function with args + * + * > Can also test if SET or GET command return SL_STATUS_NOT_SUPPORTED if node == INVALID_STORAGE_TYPE + * + * @param command_id Command that should be in resolver_functions + * @param base_node Base node on which the GET function will be called. If INVALID_STORAGE_TYPE expect the SET or GET function to return SL_STATUS_NOT_SUPPORTED and return. + * @param nodes Node data that will be used to check and construct the SET or GET frame (order matter since the first one will be the first argument, etc..) + * @param extra_bytes Extra bytes that will be added to the frame + */ +void helper_test_set_get_with_args( + uint8_t command_id, attribute_store_node_t base_node, std::vector< std::pair> nodes - = {}) + = {}, + std::vector extra_bytes = {}) { - auto &get_func = resolver_functions[get_command_id]; + auto &command_func = resolver_functions[command_id]; // Ask for a Get Command, should always be the same TEST_ASSERT_NOT_NULL_MESSAGE( - get_func, - "Couldn't find get function in resolver_functions."); + command_func, + "Couldn't find command function in resolver_functions."); if (base_node == ATTRIBUTE_STORE_INVALID_NODE) { TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_NOT_SUPPORTED, - get_func(base_node, received_frame, &received_frame_size), + command_func(base_node, received_frame, &received_frame_size), "Command function should have returned SL_STATUS_NOT_SUPPORTED since no " "node " "was provided"); @@ -229,11 +236,11 @@ void helper_test_get_with_args( TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - get_func(base_node, received_frame, &received_frame_size), - "Get function should have returned OK"); + command_func(base_node, received_frame, &received_frame_size), + "Command function should have returned SL_STATUS_OK"); std::vector expected_frame - = {COMMAND_CLASS_USER_CREDENTIAL, get_command_id}; + = {COMMAND_CLASS_USER_CREDENTIAL, command_id}; for (auto &node_data: nodes) { auto node = node_data.first; @@ -293,7 +300,7 @@ void helper_test_get_with_args( default: TEST_FAIL_MESSAGE( - "Unkown storage type in helper_test_get_with_args_happy_case"); + "Unkown storage type in helper_test_set_get_with_args_happy_case"); } std::string message @@ -302,13 +309,17 @@ void helper_test_get_with_args( TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); } + for(auto &byte : extra_bytes) { + expected_frame.push_back(byte); + } + TEST_ASSERT_EQUAL_MESSAGE(expected_frame.size(), received_frame_size, - "Get frame size is incorrect"); + "Command frame size is incorrect"); TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_frame.data(), received_frame, received_frame_size, - "Get frame contents mismatch"); + "Command frame contents mismatch"); } void helper_test_string_value( @@ -353,20 +364,35 @@ static sl_status_t attribute_resolver_function_t get_func, int cmock_num_calls) { + std::string message; + std::string node_name = attribute_store_get_type_name(node_type); + if (attributes_binding.find(node_type) != attributes_binding.end()) { const auto func = attributes_binding[node_type]; if (func.get_func_id == 0) { - TEST_ASSERT_NULL(get_func); + message + = "GET function should not be defined for " + node_name + + ". Did you forget to add it to the attributes_binding variable ?"; + TEST_ASSERT_NULL_MESSAGE(get_func, message.c_str()); } else { - TEST_ASSERT_NOT_NULL(get_func); + message = "SET function should be defined for " + node_name + + ". Did you forget to remove it to the attributes_binding " + "variable ?"; + TEST_ASSERT_NOT_NULL_MESSAGE(get_func, message.c_str()); resolver_functions[func.get_func_id] = get_func; } if (func.set_func_id == 0) { - TEST_ASSERT_NULL(set_func); + message + = "SET function should not be defined for " + node_name + + ". Did you forget to add it to the attributes_binding variable ?"; + TEST_ASSERT_NULL_MESSAGE(set_func, message.c_str()); } else { - TEST_ASSERT_NOT_NULL(set_func); + message = "SET function should be defined for " + node_name + + ". Did you forget to remove it to the attributes_binding " + "variable ?"; + TEST_ASSERT_NOT_NULL_MESSAGE(set_func, message.c_str()); resolver_functions[func.set_func_id] = set_func; } } @@ -760,7 +786,7 @@ void test_user_credential_user_get_happy_case() void test_user_credential_user_get_not_found() { - helper_test_get_with_args(USER_GET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_set_get_with_args(USER_GET, ATTRIBUTE_STORE_INVALID_NODE); } std::vector helper_create_user_report_frame( @@ -1126,30 +1152,157 @@ void test_user_credential_user_report_user_deleted() } //////////////////////////////////////////////////////////////////////////// -// Credential Get/Report +// Credential Set/Get/Report //////////////////////////////////////////////////////////////////////////// -void test_user_credential_credential_get_happy_case() +//>> Set +void test_user_credential_credential_set_1byte_happy_case() { - user_credential_user_unique_id_t user_id = 12; - auto user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_ADD; + std::vector credential_data = {12}; + + // Create the node with reported attribute + auto nodes = helper_create_credential_structure(12, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + auto user_node = nodes.user_id_node; + auto credential_type_node = nodes.credential_type_node; + auto credential_slot_node = nodes.credential_slot_node; + + // Operation type + auto operation_type_node + = attribute_store_emplace_desired(credential_slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); + // CREDENTIAL_DATA + uint8_t credential_data_length = credential_data.size(); + auto credential_data_length_node + = attribute_store_emplace_desired(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &credential_data_length, + sizeof(uint8_t)); + + auto credential_data_node + = attribute_store_emplace_desired(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data.data(), + credential_data.size()); + + helper_test_set_get_with_args(CREDENTIAL_SET, + operation_type_node, + { + {user_node, REPORTED_ATTRIBUTE}, + {credential_type_node, REPORTED_ATTRIBUTE}, + {credential_slot_node, REPORTED_ATTRIBUTE}, + {operation_type_node, DESIRED_ATTRIBUTE}, + {credential_data_node, DESIRED_ATTRIBUTE}, + }); +} - user_credential_type_t credential_type = 2; - auto credential_type_node - = attribute_store_emplace_desired(user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); +void test_user_credential_credential_set_12byte_happy_case() +{ + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_MODIFY; + std::vector credential_data + = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; + + // Create the node with reported attribute + auto nodes = helper_create_credential_structure(12, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + auto user_node = nodes.user_id_node; + auto credential_type_node = nodes.credential_type_node; + auto credential_slot_node = nodes.credential_slot_node; + + // Operation type + auto operation_type_node + = attribute_store_emplace_desired(credential_slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); + // CREDENTIAL_DATA + uint8_t credential_data_length = credential_data.size(); + auto credential_data_length_node + = attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &credential_data_length, + sizeof(uint8_t)); + + auto credential_data_node + = attribute_store_emplace(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data.data(), + credential_data.size()); + + helper_test_set_get_with_args(CREDENTIAL_SET, + operation_type_node, + { + {user_node, REPORTED_ATTRIBUTE}, + {credential_type_node, REPORTED_ATTRIBUTE}, + {credential_slot_node, REPORTED_ATTRIBUTE}, + {operation_type_node, DESIRED_ATTRIBUTE}, + {credential_data_node, REPORTED_ATTRIBUTE}, + }); +} + +void test_user_credential_credential_set_invalid_node() +{ + helper_test_set_get_with_args(CREDENTIAL_SET, ATTRIBUTE_STORE_INVALID_NODE); +} + +void test_user_credential_credential_set_delete_happy_case() +{ + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_DELETE; + + // Create the node with reported attribute + auto nodes = helper_create_credential_structure(12, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + auto user_node = nodes.user_id_node; + auto credential_type_node = nodes.credential_type_node; + auto credential_slot_node = nodes.credential_slot_node; + + // Operation type + auto operation_type_node + = attribute_store_emplace_desired(credential_slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); + + helper_test_set_get_with_args(CREDENTIAL_SET, + operation_type_node, + { + {user_node, REPORTED_ATTRIBUTE}, + {credential_type_node, REPORTED_ATTRIBUTE}, + {credential_slot_node, REPORTED_ATTRIBUTE}, + {operation_type_node, DESIRED_ATTRIBUTE}, + }, + {0x00} // Credential data length + ); +} + + +//>> Get +void test_user_credential_credential_get_happy_case() +{ + user_credential_type_t credential_type = 2; user_credential_slot_t credential_slot = 1212; - auto credential_slot_node - = attribute_store_emplace_desired(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); + + auto nodes + = helper_create_credential_structure(12, credential_type, credential_slot); + auto user_node = nodes.user_id_node; + auto credential_type_node = nodes.credential_type_node; + auto credential_slot_node = nodes.credential_slot_node; // Get should make both credential_type_node and credential_slot_node reported value as the desired values helper_test_set_get_with_args(CREDENTIAL_GET, @@ -1163,7 +1316,7 @@ void test_user_credential_credential_get_happy_case() void test_user_credential_credential_get_no_credential_type() { - helper_test_get_with_args(CREDENTIAL_GET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_set_get_with_args(CREDENTIAL_GET, ATTRIBUTE_STORE_INVALID_NODE); } std::vector helper_create_credential_report_frame( @@ -1576,7 +1729,7 @@ void test_user_credential_credential_report_happy_case() credential_modifier_node_id = 12; next_credential_type = 0; next_credential_slot = 0; - // TODO : check if we need helper_check_reported_but_no_desired_attribute + report_frame = helper_create_credential_report_frame(user_id, credential_type, From 236deabd57f130c4737ac0a381f9ea994cd818a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 9 Apr 2024 16:03:49 +0200 Subject: [PATCH 04/60] UIC-3222: User Set UIC-3222: User set on User Operation Type UIC-3222: More user types UIC-3222: User SET fix UIC-3222: Set User (delete) improvement UIC-3222: Fix expiring minutes to Desired Or Reported to allow add UIC-3222: User SET can look into desired attributes --- ...wave_command_class_user_credential_types.h | 21 +- .../zpc_attribute_store_type_registration.cpp | 2 - .../zwave_command_class_user_credential.cpp | 185 +++++++++++++----- ...ave_command_class_user_credential_test.cpp | 135 ++++++++++++- 4 files changed, 282 insertions(+), 61 deletions(-) diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index db365aa97..c7b14cbe5 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -40,19 +40,36 @@ typedef uint8_t user_credential_user_modifier_type_t; ///> User Modifier Node ID. uint16_t typedef uint16_t user_credential_user_modifier_node_id_t; ///> User Type. uint8_t +#define USER_CREDENTIAL_USER_TYPE_GENERAL_USER 0x00 +#define USER_CREDENTIAL_USER_TYPE_PROGRAMMING_USER 0x03 +#define USER_CREDENTIAL_USER_TYPE_NON_ACCESS_USER 0x04 +#define USER_CREDENTIAL_USER_TYPE_DURESS_USER 0x05 +#define USER_CREDENTIAL_USER_TYPE_DISPOSABLE_USER 0x06 +#define USER_CREDENTIAL_USER_TYPE_EXPIRING_USER 0x07 +#define USER_CREDENTIAL_USER_TYPE_REMOTE_ONLY_USER 0x09 typedef uint8_t user_credential_user_type_t; +///> User active state (0 or 1). uint8_t +typedef uint8_t user_credential_user_active_state_t; +///> User name encoding. uint8_t +typedef uint8_t user_credential_user_name_encoding_t; ///> Credential type. uint8_t typedef uint8_t user_credential_type_t; +///> Credential rule. uint8_t +typedef uint8_t user_credential_rule_t; + ///> Credential slot. uint16_t typedef uint16_t user_credential_slot_t; ///> Operation type. uint8_t +#define USER_CREDENTIAL_OPERATION_TYPE_ADD 0x00 +#define USER_CREDENTIAL_OPERATION_TYPE_MODIFY 0x01 +#define USER_CREDENTIAL_OPERATION_TYPE_DELETE 0x02 typedef uint8_t user_credential_operation_type_t; -///> Operation type. uint8_t -typedef uint8_t user_credential_operation_type_t; +///> Expiring Timeout for User (Minutes). uint16_t +typedef uint16_t user_credential_expiring_timeout_minutes_t; #ifdef __cplusplus extern "C" { diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index 9d5c2144b..ec1772be6 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -501,8 +501,6 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, "User Credential Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, "User Credential Credential Data Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, "User Credential Credential Data", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, BYTE_ARRAY_STORAGE_TYPE}, - - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, "User Credential Credential Read Back Flag", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, "User Credential Credential Modifier type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, "User Credential Credential Node ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index dc232a6bc..5a3810ae0 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -149,14 +149,15 @@ bool get_user_id_node(attribute_store_node_t endpoint_node, attribute_store_node_value_state_t state, attribute_store_node_t &user_id_node) { - user_id_node = attribute_store_get_node_child_by_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - state, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - return attribute_store_node_exists(user_id_node); + user_id_node + = attribute_store_get_node_child_by_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + state, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + return attribute_store_node_exists(user_id_node); } /** @@ -333,11 +334,12 @@ sl_status_t * * @return sl_status_t SL_STATUS_OK if everything was fine */ -sl_status_t create_command_frame(uint8_t command, - std::vector command_data, - attribute_store_node_t base_node, - uint8_t *frame, - uint16_t *frame_length) +sl_status_t + create_command_frame(uint8_t command, + std::vector command_data, + attribute_store_node_t base_node, + uint8_t *frame, + uint16_t *frame_length) { frame[0] = COMMAND_CLASS_USER_CREDENTIAL; frame[1] = command; @@ -392,11 +394,10 @@ sl_status_t create_command_frame(uint8_t command, auto credential_length_node = attribute_store_get_node_parent(node); uint8_t credential_data_length = 0; - status = attribute_store_read_value( - credential_length_node, - attribute_info.attribute_state, - &credential_data_length, - sizeof(credential_data_length)); + status = attribute_store_read_value(credential_length_node, + attribute_info.attribute_state, + &credential_data_length, + sizeof(credential_data_length)); if (status != SL_STATUS_OK) { sl_log_error( @@ -444,7 +445,8 @@ sl_status_t create_command_frame(uint8_t command, break; } - std::string user_name = c_user_name; + std::string user_name = c_user_name; + frame[current_index++] = user_name.length(); for (const char &c: user_name) { frame[current_index++] = c; } @@ -536,7 +538,7 @@ sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( if (frame_length < INDEX_BITMASK_LENGTH) { return SL_STATUS_NOT_SUPPORTED; } - + sl_log_debug(LOG_TAG, "User Capabilities Report"); attribute_store_node_t endpoint_node @@ -650,7 +652,7 @@ sl_status_t if (frame_length < 5) { return SL_STATUS_NOT_SUPPORTED; } - + sl_log_debug(LOG_TAG, "Credential Capabilities Report"); attribute_store_node_t endpoint_node @@ -671,10 +673,10 @@ sl_status_t // Remove all previous known CREDENTIAL_TYPE attribute_store_node_t type_node; do { - type_node - = attribute_store_get_node_child_by_type(endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - 0); + type_node = attribute_store_get_node_child_by_type( + endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + 0); attribute_store_delete_node(type_node); } while (type_node != ATTRIBUTE_STORE_INVALID_NODE); @@ -763,9 +765,8 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( if (frame_length != 4) { return SL_STATUS_NOT_SUPPORTED; } - - sl_log_debug(LOG_TAG, "All User Checksum Report"); + sl_log_debug(LOG_TAG, "All User Checksum Report"); attribute_store_node_t endpoint_node = zwave_command_class_get_endpoint_node(connection_info); @@ -787,13 +788,14 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( // Start credential interview process by starting with 0,0 void trigger_get_credential(attribute_store_node_t user_unique_id_node, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) { sl_log_debug(LOG_TAG, "Trigger GET credential for user %d : " "Credential type %d, credential slot %d", - static_cast(attribute_store_get_reported_number(user_unique_id_node)), + static_cast( + attribute_store_get_reported_number(user_unique_id_node)), credential_type, credential_slot); @@ -1192,8 +1194,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( if (next_credential_type != 0 && next_credential_slot != 0) { trigger_get_credential(user_unique_id_node, - next_credential_type, - next_credential_slot); + next_credential_type, + next_credential_slot); sl_log_debug(LOG_TAG, "Next credential type and slot: %d, %d", next_credential_type, @@ -1206,12 +1208,12 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( } ///////////////////////////////////////////////////////////////////////////// -// User Get/Report +// User Set/Get/Report ///////////////////////////////////////////////////////////////////////////// // Start user interview process by starting a user get with ID 0 void trigger_get_user(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) + user_credential_user_unique_id_t user_id) { // If we are not in the special case of user ID 0 we need to check if user is already here if (user_id != 0) { @@ -1224,11 +1226,14 @@ void trigger_get_user(attribute_store_node_t endpoint_node, 0); // If it exists we interview it again if (attribute_store_node_exists(user_node)) { - sl_log_debug(LOG_TAG, "User Unique ID %d found. Undefine its reported value to update it.", user_id); + sl_log_debug( + LOG_TAG, + "User Unique ID %d found. Undefine its reported value to update it.", + user_id); attribute_store_set_desired(user_node, &user_id, sizeof(user_id)); attribute_store_undefine_reported(user_node); return; - } + } } // If user id is 0 or not existant we create it @@ -1239,6 +1244,73 @@ void trigger_get_user(attribute_store_node_t endpoint_node, sizeof(user_id)); } +static sl_status_t zwave_command_class_user_credential_user_set( + attribute_store_node_t user_operation_type_node, + uint8_t *frame, + uint16_t *frame_length) +{ + // Get user unique id node + attribute_store_node_t user_unique_id_node + = attribute_store_get_first_parent_with_type(user_operation_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + user_credential_user_unique_id_t user_id = 0; + attribute_store_get_desired_else_reported(user_unique_id_node, + &user_id, + sizeof(user_id)); + + sl_log_debug(LOG_TAG, "User SET for user %d", user_id); + + // If we can't get the user unique id we can't continue + if (!attribute_store_node_exists(user_unique_id_node)) { + return SL_STATUS_NOT_SUPPORTED; + } + + user_credential_operation_type_t user_operation_type = 0; + sl_status_t status = attribute_store_get_desired(user_operation_type_node, + &user_operation_type, + sizeof(user_operation_type)); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get user operation type value. Not sending USER_SET."); + return SL_STATUS_NOT_SUPPORTED; + } + + std::vector set_data = { + {ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, + {ATTRIBUTE(USER_UNIQUE_ID), DESIRED_OR_REPORTED_ATTRIBUTE, user_unique_id_node} + }; + + // If we are not deleting the user we need more data + if (user_operation_type != USER_SET_OPERATION_TYPE_DELETE) { + std::vector extra_set_data = { + {ATTRIBUTE(USER_TYPE), DESIRED_OR_REPORTED_ATTRIBUTE}, + {ATTRIBUTE(USER_ACTIVE_STATE), DESIRED_OR_REPORTED_ATTRIBUTE}, + {ATTRIBUTE(CREDENTIAL_RULE), DESIRED_OR_REPORTED_ATTRIBUTE}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), DESIRED_OR_REPORTED_ATTRIBUTE}, + {ATTRIBUTE(USER_NAME_ENCODING), DESIRED_OR_REPORTED_ATTRIBUTE}, + {ATTRIBUTE(USER_NAME), DESIRED_OR_REPORTED_ATTRIBUTE}, + }; + std::copy(extra_set_data.begin(), + extra_set_data.end(), + std::back_inserter(set_data)); + } + + status = create_command_frame(USER_SET, + set_data, + user_unique_id_node, + frame, + frame_length); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Can't create User SET frame"); + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + static sl_status_t zwave_command_class_user_credential_user_get( attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { @@ -1307,7 +1379,9 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( sl_log_info(LOG_TAG, "User report with ID 0 received. This probably means that no " "user is defined on the device."); - sl_log_debug(LOG_TAG, "Attempt to delete User Node ID with value %d", user_id); + sl_log_debug(LOG_TAG, + "Attempt to delete User Node ID with value %d", + user_id); sl_status_t deletion_status = remove_node_0_if_exists(); sl_log_debug(LOG_TAG, "Deletion returned status : %d", deletion_status); return SL_STATUS_OK; @@ -1376,8 +1450,8 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( INDEX_USER_NAME_ENCODING, USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK}, {ATTRIBUTE(CREDENTIAL_RULE), INDEX_CREDENTIAL_RULE}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES} - }; + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES}}; sl_status_t set_status = set_reported_attributes(user_unique_id_node, frame_data, user_data); @@ -1392,10 +1466,12 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( = get_string_value(frame_data, INDEX_USER_NAME, user_name_length); // Prevent duplicate - auto user_name_node = attribute_store_get_first_child_by_type( - user_unique_id_node, ATTRIBUTE(USER_NAME)); + auto user_name_node + = attribute_store_get_first_child_by_type(user_unique_id_node, + ATTRIBUTE(USER_NAME)); if (!attribute_store_node_exists(user_name_node)) { - user_name_node = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_unique_id_node); + user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_unique_id_node); } attribute_store_set_reported_string(user_name_node, user_name.c_str()); @@ -1422,8 +1498,8 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, attribute_store_change_t change) { attribute_store_node_t node_id_node - = attribute_store_get_first_parent_with_type(updated_node, - ATTRIBUTE_NODE_ID); + = attribute_store_get_first_parent_with_type(updated_node, + ATTRIBUTE_NODE_ID); zwave_node_id_t node_id; attribute_store_get_reported(node_id_node, &node_id, sizeof(node_id)); @@ -1441,16 +1517,15 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, // If the endpoint report is marked as ONLINE_FUNCTIONAL if (reported_value_status == SL_STATUS_OK - && network_status == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) - { - sl_log_debug(LOG_TAG, - "Node %d is now ONLINE_FUNCTIONAL : start the delayed " - "interview process", - node_id); + && network_status == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { + sl_log_debug(LOG_TAG, + "Node %d is now ONLINE_FUNCTIONAL : start the delayed " + "interview process", + node_id); // Perform action on each endpoint that supports User Credential Command class uint8_t endpoint_count = attribute_store_get_node_child_count_by_type(node_id_node, - ATTRIBUTE_ENDPOINT_ID); + ATTRIBUTE_ENDPOINT_ID); sl_log_debug(LOG_TAG, "Checking endpoints (total : %d)...", endpoint_count); @@ -1461,7 +1536,6 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, ATTRIBUTE_ENDPOINT_ID, i); - zwave_endpoint_id_t endpoint_id; attribute_store_get_reported(endpoint_node, &endpoint_id, @@ -1540,8 +1614,6 @@ sl_status_t zwave_command_class_user_credential_control_handler( } } - - // Entry point sl_status_t zwave_command_class_user_credential_init() { @@ -1569,6 +1641,11 @@ sl_status_t zwave_command_class_user_credential_init() NULL, &zwave_command_class_user_credential_user_get); + attribute_resolver_register_rule( + ATTRIBUTE(USER_OPERATION_TYPE), + &zwave_command_class_user_credential_user_set, + NULL); + attribute_resolver_register_rule( ATTRIBUTE(CREDENTIAL_SLOT), NULL, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 43f65b4cf..acb34f599 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -77,6 +77,7 @@ static std::map resolver_functions; static uint8_t received_frame[255] = {}; static uint16_t received_frame_size = 0; +const uint8_t MAX_CHAR_SIZE = 64; ///////////////////////////////////////////////////// // C++ HELPERS ///////////////////////////////////////////////////// @@ -297,7 +298,23 @@ void helper_test_set_get_with_args( } } break; + case C_STRING_STORAGE_TYPE: { + char reported_c_str[MAX_CHAR_SIZE]; + + status = attribute_store_get_reported_string(node, + reported_c_str, + MAX_CHAR_SIZE); + std::string reported_cpp_str = reported_c_str; + if (reported_cpp_str.empty()) { + TEST_FAIL_MESSAGE("Can't get string value"); + } + + expected_frame.push_back(reported_cpp_str.length()); + for (const char &c: reported_cpp_str) { + expected_frame.push_back(c); + } + } break; default: TEST_FAIL_MESSAGE( "Unkown storage type in helper_test_set_get_with_args_happy_case"); @@ -331,7 +348,6 @@ void helper_test_string_value( } for (auto &attr: attribute_map_values) { - constexpr uint8_t MAX_CHAR_SIZE = 64; char reported_c_str[MAX_CHAR_SIZE]; auto str_node = attribute_store_get_first_child_by_type(parent, attr.first); @@ -769,8 +785,121 @@ void test_user_credential_all_users_checksum_report_happy_case() } //////////////////////////////////////////////////////////////////////////// -// User Get/Report +// User Set/Get/Report //////////////////////////////////////////////////////////////////////////// +void test_user_credential_user_set_add_or_modify_happy_case() +{ + user_credential_user_unique_id_t user_id = 12121; + user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_ADD; + user_credential_type_t user_type = 5; + user_credential_rule_t credential_rule = 2; + user_credential_user_active_state_t user_active_state = 1; + user_credential_expiring_timeout_minutes_t expiring_timeout = 55; + user_credential_user_name_encoding_t user_name_encoding = 0; + std::string user_name = "DoUzE"; + + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + auto operation_type_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); + auto user_type_node = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_TYPE), + &user_type, + sizeof(user_type)); + auto user_active_state_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE), + &user_active_state, + sizeof(user_active_state)); + auto credential_rule_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE), + &credential_rule, + sizeof(credential_rule)); + auto expiring_timeout_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); + auto user_name_encoding_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + &user_name_encoding, + sizeof(user_name_encoding)); + auto user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); + + sl_status_t status + = attribute_store_set_reported_string(user_name_node, user_name.c_str()); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, "Can't set username"); + + printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); + helper_test_set_get_with_args( + USER_SET, + operation_type_node, + {{operation_type_node, DESIRED_ATTRIBUTE}, + {user_id_node, REPORTED_ATTRIBUTE}, + {user_type_node, DESIRED_ATTRIBUTE}, + {user_active_state_node, REPORTED_ATTRIBUTE}, + {credential_rule_node, DESIRED_ATTRIBUTE}, + {expiring_timeout_node, REPORTED_ATTRIBUTE}, + {user_name_encoding_node, DESIRED_ATTRIBUTE}, + {user_name_node, REPORTED_ATTRIBUTE}}); + + + printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); + + operation_type = USER_SET_OPERATION_TYPE_ADD; + attribute_store_set_desired(operation_type_node, + &operation_type, + sizeof(operation_type)); + helper_test_set_get_with_args( + USER_SET, + operation_type_node, + {{operation_type_node, DESIRED_ATTRIBUTE}, + {user_id_node, REPORTED_ATTRIBUTE}, + {user_type_node, DESIRED_ATTRIBUTE}, + {user_active_state_node, REPORTED_ATTRIBUTE}, + {credential_rule_node, DESIRED_ATTRIBUTE}, + {expiring_timeout_node, REPORTED_ATTRIBUTE}, + {user_name_encoding_node, DESIRED_ATTRIBUTE}, + {user_name_node, REPORTED_ATTRIBUTE}}); +} + +void test_user_credential_user_delete_remove_happy_case() +{ + user_credential_user_unique_id_t user_id = 12121; + user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_DELETE; + + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + auto operation_type_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); + + helper_test_set_get_with_args(USER_SET, + operation_type_node, + {{operation_type_node, DESIRED_ATTRIBUTE}, + {user_id_node, REPORTED_ATTRIBUTE}}); +} + +void test_user_credential_user_set_invalid_node() +{ + helper_test_set_get_with_args(USER_SET, ATTRIBUTE_STORE_INVALID_NODE); +} + + void test_user_credential_user_get_happy_case() { user_credential_user_unique_id_t user_id = 12; @@ -795,7 +924,7 @@ std::vector helper_create_user_report_frame( user_credential_user_modifier_node_id_t user_modifier_node_id, user_credential_user_unique_id_t user_id, user_credential_user_type_t user_type, - uint8_t user_active_state, + user_credential_user_active_state_t user_active_state, user_credential_supported_credential_rules_t credential_rule, user_credential_expiring_timeout_minutes_t expiring_timeout_minutes, user_credential_user_name_encoding_t user_name_encoding, From af8642b5ef99c152a242f19127b0a6c1815675e9 Mon Sep 17 00:00:00 2001 From: Philippe Coval Date: Mon, 20 Jan 2025 16:38:17 +0100 Subject: [PATCH 05/60] UIC-3222: Unify_UserCredential cluster integration in ZPC UIC-3222: Expose New credential capabilities UIC-3222: Expose Admin Code [Philippe Coval] Adjusted applications/zpc/components/zwave_command_classes/test/CMakeLists.txt --- .../dotdot_mapper/rules/UserCredential.uam | 27 + .../zcl_cluster_servers/CMakeLists.txt | 1 + ...configuration_parameter_cluster_server.cpp | 2 +- .../src/user_credential_cluster_server.cpp | 714 +++++++ .../src/user_credential_cluster_server.h | 42 + .../src/zcl_cluster_servers.cpp | 2 + .../zcl_cluster_servers/test/CMakeLists.txt | 18 +- .../user_credential_cluster_server_test.cpp | 1650 +++++++++++++++++ .../test/workaround_for_test.hpp | 25 + ...wave_command_class_user_credential_types.h | 5 + .../zwave_command_classes/CMakeLists.txt | 3 + .../zwave_command_class_user_credential.cpp | 1241 ++++++++++++- .../src/zwave_command_class_user_credential.h | 133 ++ .../zwave_command_classes/test/CMakeLists.txt | 7 +- ...ave_command_class_user_credential_test.cpp | 557 +++++- 15 files changed, 4337 insertions(+), 90 deletions(-) create mode 100644 applications/zpc/components/dotdot_mapper/rules/UserCredential.uam create mode 100644 applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp create mode 100644 applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.h create mode 100644 applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp create mode 100644 applications/zpc/components/zcl_cluster_servers/test/workaround_for_test.hpp diff --git a/applications/zpc/components/dotdot_mapper/rules/UserCredential.uam b/applications/zpc/components/dotdot_mapper/rules/UserCredential.uam new file mode 100644 index 000000000..40f64380f --- /dev/null +++ b/applications/zpc/components/dotdot_mapper/rules/UserCredential.uam @@ -0,0 +1,27 @@ +// User Credential CC +def zwUSER_CREDENTIAL_USER_COUNT 0x8302 +def zwUSER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES 0x8303 +def zwUSER_CREDENTIAL_SUPPORTED_USER_TYPES 0x8308 +def zwUSER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM 0x8309 +def zwUSER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE 0x830A +def zwUSER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION 0x830B + +// This represents short CamelCase labels the attributes in the DotDot UserCredential cluster +def zb_SupportedUserUniqueIdentifiers 0xfd080000 +def zb_SupportedCredentialRules 0xfd080001 +// def zb_SupportedCredentialTypes 0xfd080002 Binding is done in user_credential directly +def zb_SupportedUserTypes 0xfd080003 +def zb_SupportCredentialChecksum 0xfd080004 +def zb_SupportAdminPinCode 0xfd080005 +def zb_SupportAdminPinCodeDeactivation 0xfd080006 +// def zb_AdminPinCode 0xfd080007 Binding is done in user_credential_cluster_server directly + +scope 0 chain_reaction(0) { + r'zb_SupportedUserUniqueIdentifiers = r'zwUSER_CREDENTIAL_USER_COUNT + r'zb_SupportedCredentialRules = r'zwUSER_CREDENTIAL_SUPPORTED_CREDENTIAL_RULES + r'zb_SupportedUserTypes = r'zwUSER_CREDENTIAL_SUPPORTED_USER_TYPES + + r'zb_SupportCredentialChecksum = r'zwUSER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM + r'zb_SupportAdminPinCode = r'zwUSER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE + r'zb_SupportAdminPinCodeDeactivation = r'zwUSER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION +} \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/CMakeLists.txt b/applications/zpc/components/zcl_cluster_servers/CMakeLists.txt index 8827e1f08..bef0569bc 100644 --- a/applications/zpc/components/zcl_cluster_servers/CMakeLists.txt +++ b/applications/zpc/components/zcl_cluster_servers/CMakeLists.txt @@ -9,6 +9,7 @@ add_library( zcl_cluster_servers src/configuration_parameter_cluster_server.cpp src/humidity_control_cluster_server.c + src/user_credential_cluster_server.cpp src/user_code_cluster_server.cpp src/fan_control_cluster_server.c src/zcl_binding_cluster_server.cpp diff --git a/applications/zpc/components/zcl_cluster_servers/src/configuration_parameter_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/configuration_parameter_cluster_server.cpp index 5c57bd403..3f2c928e1 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/configuration_parameter_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/configuration_parameter_cluster_server.cpp @@ -521,7 +521,7 @@ static void clear_configuration_parameters_vector(configuration); // Do it again for the Reported value - get_configuration_parameters(endpoint_id_node, + get_configuration_parameters(endpoint_id_node, configuration, REPORTED_ATTRIBUTE); uic_mqtt_dotdot_configuration_parameters_configuration_parameters_publish( diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp new file mode 100644 index 000000000..09e072606 --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -0,0 +1,714 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ +#include "user_credential_cluster_server.h" +#include "zcl_cluster_servers_helpers.hpp" +// Interfaces +#include "zwave_command_class_user_credential.h" + +// ZPC includes +#include "zpc_attribute_store.h" +#include "zpc_attribute_store_network_helper.h" +#include "zwave_command_class_generic_types.h" +#include "attribute_store_defined_attribute_types.h" +#include "attribute_store_type_registration.h" + +// Includes from Unify shared components +#include "attribute.hpp" +#include "attribute_store_helper.h" +#include "sl_log.h" + +// Includes from auto-generated files +#include "dotdot_mqtt.h" +#include "dotdot_mqtt_helpers.hpp" +#include "zap-types.h" + +// Generic includes +#include +#include +#include +#include + +// JSON +#include + +// Boost +#include +#include + +// UTF16 conversion (deprecated in C++17) +// Needed for credential data (password) per specification +#include +#include + +// Setup Log ID +constexpr char LOG_TAG[] = "user_credential_cluster_server"; + +// Attribute macro, shortening those long defines for attribute types: +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +/////////////////////////////////////////////////////////////////////// +// Data structures +/////////////////////////////////////////////////////////////////////// +// Data structure to hold the MQTT topic and conversion function (if needed) for each attribute +struct mqtt_data { + std::string topic; + std::function convert_function = nullptr; +}; +// Used to bind an attribute to a MQTT topic +typedef std::map user_attributes_mqtt_map_t; + +/////////////////////////////////////////////////////////////////////// +// Conversion functions +/////////////////////////////////////////////////////////////////////// +std::string convert_to_bool(uint32_t value) +{ + return value ? "true" : "false"; +} + +/////////////////////////////////////////////////////////////////////// +// Static variables +/////////////////////////////////////////////////////////////////////// +// User attributes +static const user_attributes_mqtt_map_t user_attributes = { + {ATTRIBUTE(USER_TYPE), {"UserType", user_type_enum_get_enum_value_name}}, + {ATTRIBUTE(USER_ACTIVE_STATE), {"UserActiveState", convert_to_bool}}, + {ATTRIBUTE(CREDENTIAL_RULE), + {"CredentialRule", cred_rule_get_enum_value_name}}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), {"ExpiringTimeoutMinutes"}}, + {ATTRIBUTE(USER_NAME_ENCODING), + {"UserNameEncoding", user_name_encoding_type_get_enum_value_name}}, + {ATTRIBUTE(USER_MODIFIER_TYPE), + {"UserModifierType", user_modifier_type_get_enum_value_name}}, + {ATTRIBUTE(USER_MODIFIER_NODE_ID), {"UserModifierNodeId"}}, + {ATTRIBUTE(USER_NAME), {"UserName"}}, +}; + +// Credential attributes +static const user_attributes_mqtt_map_t credential_attributes + = {{ATTRIBUTE(CREDENTIAL_READ_BACK), {"CredentialReadBack", convert_to_bool}}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + {"CredentialModifierType", user_modifier_type_get_enum_value_name}}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), {"CredentialModifierNodeId"}}, + {ATTRIBUTE(CREDENTIAL_DATA), {"CredentialData"}}}; + +static const user_attributes_mqtt_map_t credential_rules_attributes + = {{ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), {"LearnSupport", convert_to_bool}}, + {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), {"SupportedSlotCount"}}, + {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), {"CredentialMinLength"}}, + {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), {"CredentialMaxLength"}}, + {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + {"LearnRecommendedTimeout"}}, + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), {"LearnNumberOfSteps"}}}; + +/////////////////////////////////////////////////////////////////////////////// +// DotDot MQTT incoming commands handling functions +////////////////////////////////////////////////////////////////////////////// +static sl_status_t + add_user_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + UserTypeEnum user_type, + bool user_active_state, + CredRule credential_rule, + const char *user_name, + uint16_t expiring_timeout_minutes, + UserNameEncodingType user_name_encoding) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_add_new_user( + endpoint_node, + user_uniqueid, + static_cast(user_type), + static_cast(credential_rule), + user_active_state, + expiring_timeout_minutes, + static_cast(user_name_encoding), + user_name); +} + +static sl_status_t + modify_user_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + UserTypeEnum user_type, + bool user_active_state, + CredRule credential_rule, + const char *user_name, + uint16_t expiring_timeout_minutes, + UserNameEncodingType user_name_encoding) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_modify_user( + endpoint_node, + user_uniqueid, + static_cast(user_type), + static_cast(credential_rule), + user_active_state, + expiring_timeout_minutes, + static_cast(user_name_encoding), + user_name); + + return SL_STATUS_OK; +} + +static sl_status_t + delete_user_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_user(endpoint_node, + user_uniqueid); +} + +static sl_status_t + add_credential_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + const char *credential_data) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_add_new_credential( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + credential_slot, + credential_data); +} + +static sl_status_t + modify_credential_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + const char *credential_data) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + return zwave_command_class_user_credential_modify_credential( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + credential_slot, + credential_data); +} + +static sl_status_t + delete_credential_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_credential( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + credential_slot); +} + +/////////////////////////////////////////////////////////////////////////////// +// Helpers functions +////////////////////////////////////////////////////////////////////////////// +void register_attributes_to_mqtt_map( + const user_attributes_mqtt_map_t &map, + attribute_store_node_changed_callback_t callback) +{ + sl_status_t status = SL_STATUS_OK; + for (const auto &[attribute_store_type, mqtt_data]: map) { + status |= attribute_store_register_callback_by_type_and_state( + callback, + attribute_store_type, + REPORTED_ATTRIBUTE); + } + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Failed to register callbacks for User Credential"); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// MQTT Helpers functions +////////////////////////////////////////////////////////////////////////////// + +/** + * @brief Get the base MQTT topic for a UserCredential. + * + * This function will return the base MQTT topic for a UserCredential based on the + * updated node. The topic will be in the format: + * ucl/by-unid//ep/UserCredential/Attributes +*/ +std::string get_base_mqtt_topic(attribute_store::attribute updated_node_cpp) +{ + boost::format mqtt_topic + = boost::format("ucl/by-unid/%1%/ep%2%/UserCredential/Attributes"); + + // Go up and find the UNID/Endpoint and its network status. + unid_t unid; + zwave_endpoint_id_t endpoint_id = 0; + if (SL_STATUS_OK + != attribute_store_network_helper_get_unid_endpoint_from_node( + updated_node_cpp, + unid, + &endpoint_id)) { + return ""; + } + + // Do not publish any state supported commands for ourselves. + if (is_zpc_unid(unid)) { + return ""; + } + + // Need to convert endpoint_id to an unsigned int to be displayed as an int and not a char + return (mqtt_topic % unid % static_cast(endpoint_id)).str(); +} + +/** + * @brief Get the base MQTT topic for a user. + * + * This function will return the base MQTT topic for a user based on the + * updated node. The topic will be in the format: + * ucl/by-unid//ep/UserCredential/Attributes/User/ + * + * @param updated_node_cpp The node that will be published. + * @return The base MQTT topic for the user. + */ +std::string + get_base_user_mqtt_topic(attribute_store::attribute updated_node_cpp) +{ + boost::format mqtt_topic + = boost::format("%1%/User/%2%"); + + std::string base_mqtt_topic = get_base_mqtt_topic(updated_node_cpp); + if (base_mqtt_topic.empty()) { + return ""; + } + + try { + user_credential_user_unique_id_t user_id + = updated_node_cpp.first_parent_or_self(ATTRIBUTE(USER_UNIQUE_ID)) + .reported(); + + return (mqtt_topic % base_mqtt_topic % user_id) + .str(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while publishing User attribute (%s) : %s", + attribute_store_type_get_node_type_name(updated_node_cpp), + e.what()); + } + + return ""; +} + +/** + * @brief Get the base MQTT topic for a credential. + * + * This function will return the base MQTT topic for a credential based on the + * updated node. The topic will be in the format: + * ucl/by-unid//ep/UserCredential/Attributes/User//Credential////Reported + * + * @param updated_node_cpp The updated node. + * @return The base MQTT topic for the credential. + */ +std::string + get_base_credential_mqtt_topic(attribute_store::attribute updated_node_cpp) +{ + std::string base_user_mqtt_topic = get_base_user_mqtt_topic(updated_node_cpp); + if (base_user_mqtt_topic.empty()) { + return ""; + } + + try { + user_credential_slot_t credential_slot + = updated_node_cpp.first_parent(ATTRIBUTE(CREDENTIAL_SLOT)) + .reported(); + + user_credential_type_t credential_type + = updated_node_cpp.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)) + .reported(); + std::string credential_type_str + = cred_type_get_enum_value_name(credential_type); + + return (boost::format("%1%/Credential/%2%/%3%") % base_user_mqtt_topic + % credential_type_str % credential_slot) + .str(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while publishing Credential attribute (%s) : %s", + attribute_store_type_get_node_type_name(updated_node_cpp), + e.what()); + } + + return ""; +} + +std::string + get_base_credential_rule_mqtt_topic(attribute_store::attribute updated_node_cpp) +{ + std::string base_user_mqtt_topic = get_base_mqtt_topic(updated_node_cpp); + if (base_user_mqtt_topic.empty()) { + return ""; + } + + try { + user_credential_type_t credential_type + = updated_node_cpp.first_parent(ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)) + .reported(); + std::string credential_type_str + = cred_type_get_enum_value_name(credential_type); + + return (boost::format("%1%/Credentials/%2%") % base_user_mqtt_topic + % credential_type_str) + .str(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while publishing Credential Rule attribute (%s) : %s", + attribute_store_type_get_node_type_name(updated_node_cpp), + e.what()); + } + + return ""; +} + +/** + * @brief Add an attribute to the MQTT topic. + * + * This function will add an attribute to the MQTT topic. The topic will be in + * the format: + * //Reported + * + * @param base_mqtt_topic The base MQTT topic. + * @param attribute_name The attribute name to add. + * @return The full MQTT topic. + */ +std::string mqtt_topic_add_attribute(const std::string &base_mqtt_topic, + const std::string &attribute_name) +{ + return (boost::format("%1%/%2%/Reported") % base_mqtt_topic % attribute_name) + .str(); +} + +/** + * @brief Get the payload value for the attribute. + * + * This function will get the payload value for the attribute. The payload will + * be in the format: + * { + * "value": + * } + * + * @param updated_node_cpp The updated node. + * @param data The MQTT data. + * @param need_utf8_conversion If the value needs to be converted to UTF-8. Only applies to C_STRING_STORAGE_TYPE. + * + * @return The payload value. + */ +std::string get_payload_value(attribute_store::attribute updated_node_cpp, + mqtt_data data, + bool need_utf8_conversion = false) +{ + std::string payload_str = ""; + + auto node_storage_type + = attribute_store_get_storage_type(updated_node_cpp.type()); + nlohmann::json json_payload; + switch (node_storage_type) { + case U8_STORAGE_TYPE: + json_payload["value"] = updated_node_cpp.reported(); + break; + case U16_STORAGE_TYPE: + json_payload["value"] = updated_node_cpp.reported(); + break; + case U32_STORAGE_TYPE: + json_payload["value"] = updated_node_cpp.reported(); + break; + case C_STRING_STORAGE_TYPE: + json_payload["value"] = updated_node_cpp.reported(); + break; + case BYTE_ARRAY_STORAGE_TYPE: { + // Convert the byte array to a string + // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value + + std::string output; + auto data = updated_node_cpp.reported>(); + + // Check if we need to convert the value to UTF-8 + if (need_utf8_conversion) { + std::u16string utf16_str; + for(size_t i=0; i, char16_t> cnv; + output = cnv.to_bytes(utf16_str); + if (cnv.converted() < utf16_str.size()) { + sl_log_error(LOG_TAG, "Error converting UTF-16 to UTF-8"); + } + } else { + output.reserve(data.size()); + for (auto c: data) { + output.push_back(static_cast(c)); + } + } + + json_payload["value"] = output; + } break; + + default: + sl_log_error(LOG_TAG, + "Unsupported storage type for user credential attribute"); + return ""; + } + + // Check if we need to convert the enum to a string + const auto &enum_name_conversion = data.convert_function; + if (enum_name_conversion) { + json_payload["value"] = enum_name_conversion(json_payload["value"]); + } + + // Create payload + payload_str = json_payload.dump(); + // Handle booleans + if (enum_name_conversion) { + boost::replace_all(payload_str, "\"true\"", "true"); + boost::replace_all(payload_str, "\"false\"", "false"); + } + + return payload_str; +} + +void publish_mqtt_topic(const std::string &base_topic, + mqtt_data data, + attribute_store::attribute updated_node_cpp, + attribute_store_change_t change) +{ + std::string mqtt_topic = mqtt_topic_add_attribute(base_topic, data.topic); + sl_log_debug(LOG_TAG, "Publishing to topic: %s", mqtt_topic.c_str()); + + std::string payload_str = ""; + if (change != ATTRIBUTE_DELETED) { + + if (updated_node_cpp.type() == ATTRIBUTE(CREDENTIAL_DATA)) { + // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value + // We need to convert the value to UTF-8 if the credential type is password + user_credential_type_t type + = updated_node_cpp.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)) + .reported(); + payload_str = get_payload_value(updated_node_cpp, + data, + (type == ZCL_CRED_TYPE_PASSWORD)); + } else { + payload_str = get_payload_value(updated_node_cpp, data); + } + if (payload_str.empty()) { + return; + } + sl_log_debug(LOG_TAG, "Payload %s", payload_str.c_str()); + } else { + sl_log_debug(LOG_TAG, "Deletion of attribute, sending empty payload"); + } + + // Publish topic + uic_mqtt_publish(mqtt_topic.c_str(), + payload_str.c_str(), + payload_str.length(), + true); +} + +/////////////////////////////////////////////////////////////////////////////// +// Attribute monitoring +////////////////////////////////////////////////////////////////////////////// + +/** + * @brief Callback for when an attribute is updated. + * + * This function will be called when an attribute is updated. It will then + * publish the updated attribute to the MQTT broker. + * + * @param updated_node The updated node. + * @param change The change that occurred. + * @param get_base_mqtt_topic The function to get the base MQTT topic. + * @param attributes The attributes data to publish. +*/ +void on_attribute_update( + attribute_store_node_t updated_node, + attribute_store_change_t change, + std::function get_base_mqtt_topic, + const user_attributes_mqtt_map_t &attributes) +{ + try { + auto updated_node_cpp = attribute_store::attribute(updated_node); + // If no reported value exists, we wait for it + if (!updated_node_cpp.reported_exists()) { + return; + } + + // Build the base topic and pass it on to DotDot MQTT. + std::string mqtt_topic = get_base_mqtt_topic(updated_node_cpp); + if (mqtt_topic.empty()) { + return; + } + + const auto mqtt_data = attributes.at(updated_node_cpp.type()); + + publish_mqtt_topic(mqtt_topic, mqtt_data, updated_node_cpp, change); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while publishing User Credential attribute: %s", + e.what()); + } +} + +void on_user_update(attribute_store_node_t updated_node, + attribute_store_change_t change) +{ + on_attribute_update(updated_node, + change, + &get_base_user_mqtt_topic, + user_attributes); +} + +void on_credential_rules_update(attribute_store_node_t updated_node, + attribute_store_change_t change) +{ + on_attribute_update(updated_node, + change, + &get_base_credential_rule_mqtt_topic, + credential_rules_attributes); +} + +void on_credential_update(attribute_store_node_t updated_node, + attribute_store_change_t change) +{ + on_attribute_update(updated_node, + change, + &get_base_credential_mqtt_topic, + credential_attributes); +} + +/////////////////////////////////////////////////////////////////////////////// +// Init and teardown functions. +////////////////////////////////////////////////////////////////////////////// +sl_status_t user_credential_cluster_server_init() +{ + sl_log_debug(LOG_TAG, "User Credential server initialization"); + + // User properties update + register_attributes_to_mqtt_map(user_attributes, &on_user_update); + register_attributes_to_mqtt_map(credential_attributes, &on_credential_update); + register_attributes_to_mqtt_map(credential_rules_attributes, + &on_credential_rules_update); + + // Command callbacks + // User + uic_mqtt_dotdot_user_credential_add_user_callback_set(&add_user_command); + uic_mqtt_dotdot_user_credential_modify_user_callback_set( + &modify_user_command); + uic_mqtt_dotdot_user_credential_delete_user_callback_set( + &delete_user_command); + // Credential + uic_mqtt_dotdot_user_credential_add_credential_callback_set( + &add_credential_command); + uic_mqtt_dotdot_user_credential_modify_credential_callback_set( + &modify_credential_command); + uic_mqtt_dotdot_user_credential_delete_credential_callback_set( + &delete_credential_command); + + return SL_STATUS_OK; +} \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.h b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.h new file mode 100644 index 000000000..0315fb45a --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.h @@ -0,0 +1,42 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +/** + * @defgroup user_credential_cluster_server User Code Cluster Server + * @ingroup zcl_cluster_servers + * @brief The module handlers the User Code command mapping + * @{ + */ + +#ifndef USER_CREDENTIAL_CLUSTER_SERVER_H +#define USER_CREDENTIAL_CLUSTER_SERVER_H + +#include "sl_status.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Initialize the User Code Cluster Commands handler. + * + * @returns SL_STATUS_OK on success, any other code on failure + */ +sl_status_t user_credential_cluster_server_init(); + +#ifdef __cplusplus +} +#endif + +#endif //USER_CREDENTIAL_CLUSTER_SERVER_H +/** @} end user_credential_cluster_server */ diff --git a/applications/zpc/components/zcl_cluster_servers/src/zcl_cluster_servers.cpp b/applications/zpc/components/zcl_cluster_servers/src/zcl_cluster_servers.cpp index 7c959d555..43bc4c385 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/zcl_cluster_servers.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/zcl_cluster_servers.cpp @@ -19,6 +19,7 @@ #include "zcl_OTA_cluster_server.hpp" #include "user_code_cluster_server.h" #include "fan_control_cluster_server.h" +#include "user_credential_cluster_server.h" //Includes from other components #include "attribute_store.h" @@ -42,6 +43,7 @@ sl_status_t zcl_cluster_servers_init() init_status |= zcl_scenes_cluster_server_init(); init_status |= user_code_cluster_server_init(); init_status |= fan_control_cluster_server_init(); + init_status |= user_credential_cluster_server_init(); return init_status; } diff --git a/applications/zpc/components/zcl_cluster_servers/test/CMakeLists.txt b/applications/zpc/components/zcl_cluster_servers/test/CMakeLists.txt index a5142592a..6112d25e8 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/CMakeLists.txt +++ b/applications/zpc/components/zcl_cluster_servers/test/CMakeLists.txt @@ -126,4 +126,20 @@ target_add_unittest( DEPENDS zpc_attribute_store_test_helper uic_dotdot_mqtt_mock - unify_dotdot_attribute_store) \ No newline at end of file + unify_dotdot_attribute_store) + + + # User Credential Cluster Server test +target_add_unittest( + zcl_cluster_servers + NAME + user_credential_cluster_server_test + SOURCES + user_credential_cluster_server_test.cpp + DEPENDS + zpc_attribute_store_test_helper + uic_dotdot_mqtt_mock + uic_mqtt_stub + uic_attribute_store + unify) +target_include_directories(user_credential_cluster_server_test PRIVATE ../src) \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp new file mode 100644 index 000000000..5111e316b --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -0,0 +1,1650 @@ +/****************************************************************************** + * # License + * Copyright 2023 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +// Cpp +#include +#include "workaround_for_test.hpp" + +extern "C" { +#include "user_credential_cluster_server.h" +#include "zwave_command_class_user_credential.h" +#include "unity.h" + +// Definitions +#include "dotdot_cluster_id_definitions.h" +#include "attribute_store_defined_attribute_types.h" +#include "zwave_command_class_association_types.h" +#include "zap-types.h" + +// ZPC Components +#include "zpc_attribute_store_type_registration.h" + +// Test helpers +#include "zpc_attribute_store_test_helper.h" + +// Unify components +#include "datastore.h" +#include "attribute_store.h" +#include "attribute_store_helper.h" +#include "attribute_store_fixt.h" +#include "unify_dotdot_attribute_store_node_state.h" + +// Mocks +#include "dotdot_mqtt_mock.h" +#include "uic_mqtt_mock.h" + +// Attribute macro, shortening those long defines for attribute types: +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +// Header declarations +void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id); +void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot); + +// Keep a reference to the mqtt topics we want to test +// Stored as +static std::vector> mqtt_topics; +static std::vector created_user_id; +static std::vector> + created_credential_ids; + +// Callback functions +// clang-format off +uic_mqtt_dotdot_user_credential_add_user_callback_t add_user_command = NULL; +uic_mqtt_dotdot_user_credential_delete_user_callback_t delete_user_command = NULL; +uic_mqtt_dotdot_user_credential_modify_user_callback_t modify_user_command = NULL; +uic_mqtt_dotdot_user_credential_add_credential_callback_t add_credential_command = NULL; +uic_mqtt_dotdot_user_credential_modify_credential_callback_t modify_credential_command = NULL; +uic_mqtt_dotdot_user_credential_delete_credential_callback_t delete_credential_command = NULL; +// clang-format on + +// Stub functions for intercepting callback registration. +void uic_mqtt_dotdot_user_credential_add_user_callback_set_stub( + const uic_mqtt_dotdot_user_credential_add_user_callback_t callback, + int cmock_num_calls) +{ + add_user_command = callback; +} + +void uic_mqtt_dotdot_user_credential_delete_user_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_user_callback_t callback, + int cmock_num_calls) +{ + delete_user_command = callback; +} + +void uic_mqtt_dotdot_user_credential_modify_user_callback_set_stub( + const uic_mqtt_dotdot_user_credential_modify_user_callback_t callback, + int cmock_num_calls) +{ + modify_user_command = callback; +} + +void uic_mqtt_dotdot_user_credential_add_credential_callback_set_stub( + const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback, + int cmock_num_calls) +{ + add_credential_command = callback; +} +void uic_mqtt_dotdot_user_credential_modify_credential_callback_set_stub( + const uic_mqtt_dotdot_user_credential_add_credential_callback_t callback, + int cmock_num_calls) +{ + modify_credential_command = callback; +} +void uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_credential_callback_t callback, + int cmock_num_calls) +{ + delete_credential_command = callback; +} + +/// Setup the test suite (called once before all test_xxx functions are called) +void suiteSetUp() +{ + datastore_init(":memory:"); + attribute_store_init(); + zpc_attribute_store_register_known_attribute_types(); + zwave_unid_set_home_id(home_id); +} + +/// Teardown the test suite (called once after all test_xxx functions are called) +int suiteTearDown(int num_failures) +{ + attribute_store_teardown(); + datastore_teardown(); + return num_failures; +} + +/// Called before each and every test +void setUp() +{ + // Check if any users that need to be removed + for (auto user_id: created_user_id) { + // Check if MQTT topics for deletion are correctly published + mock_deletion_user_mqtt_topic(user_id); + } + for (auto cred_id: created_credential_ids) { + mock_deletion_cred_mqtt_topic(std::get<0>(cred_id), + std::get<1>(cred_id), + std::get<2>(cred_id)); + } + + zpc_attribute_store_test_helper_create_network(); + + // Intercept the dotdot MQTT callbacks + add_user_command = NULL; + modify_user_command = NULL; + delete_user_command = NULL; + add_credential_command = NULL; + + mqtt_topics.clear(); + created_user_id.clear(); + created_credential_ids.clear(); + + // clang-format off + // User + uic_mqtt_dotdot_user_credential_add_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_add_user_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_user_callback_set_stub); + uic_mqtt_dotdot_user_credential_modify_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_modify_user_callback_set_stub); + // Credentials + uic_mqtt_dotdot_user_credential_add_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_add_credential_callback_set_stub); + uic_mqtt_dotdot_user_credential_modify_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_modify_credential_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub); + // clang-format on + + // Run the component init + TEST_ASSERT_EQUAL(SL_STATUS_OK, user_credential_cluster_server_init()); +} + +///////////////////////////////////////////////////////////////////////// +// Mqtt topics helpers +///////////////////////////////////////////////////////////////////////// +std::string get_base_topic() +{ + const std::string base + = "ucl/by-unid/%1%/ep%2%/UserCredential/Attributes/User"; + return (boost::format(base) % supporting_node_unid + % (unsigned int)endpoint_id) + .str(); +} + +std::string + get_user_attribute_mqtt_topic(user_credential_user_unique_id_t user_unique_id, + const std::string &attribute_name) +{ + const std::string base = "%1%/%2%/%3%/Reported"; + return (boost::format(base) % get_base_topic() % user_unique_id + % attribute_name) + .str(); +} + +std::string + get_cred_attribute_mqtt_topic(user_credential_user_unique_id_t user_unique_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::string &attribute_name) +{ + const std::string base = "%1%/%2%/Credential/%3%/%4%/%5%/Reported"; + return (boost::format(base) % get_base_topic() % user_unique_id + % cred_type_get_enum_value_name(credential_type) % credential_slot + % attribute_name) + .str(); +} + +} // extern "C" + +template std::string get_payload(T value) +{ + nlohmann::json json_payload; + json_payload["value"] = value; + return json_payload.dump(); +} + +///////////////////////////////////////////////////////////////////////// +// MOCK HELPERS +///////////////////////////////////////////////////////////////////////// +template +void mock_expected_user_mqtt_topic(user_credential_user_unique_id_t user_id, + const std::string &attribute_name, + T payload_value) +{ + // This way we make sure that we have valid reference to our strings + mqtt_topics.push_back({get_user_attribute_mqtt_topic(user_id, attribute_name), + get_payload(payload_value)}); + + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); +} +template +void mock_expected_cred_mqtt_topic(user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::string &attribute_name, + T payload_value) +{ + // This way we make sure that we have valid reference to our strings + mqtt_topics.push_back({get_cred_attribute_mqtt_topic(user_id, + credential_type, + credential_slot, + attribute_name), + get_payload(payload_value)}); + + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); +} + +void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id) +{ + // WARNING : Order here matters based on their initialization order in the add_complete_user function + std::vector attribute_names = {"UserType", + "CredentialRule", + "UserActiveState", + "ExpiringTimeoutMinutes", + "UserNameEncoding", + "UserName", + "UserModifierNodeId", + "UserModifierType"}; + for (auto &attribute_name: attribute_names) { + mqtt_topics.push_back( + {get_user_attribute_mqtt_topic(user_id, attribute_name), ""}); + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); + } +} + +void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + // WARNING : Order here matters based on their initialization order in the add_complete_credential function + std::vector attribute_names = {"CredentialData", + "CredentialModifierNodeId", + "CredentialModifierType"}; + for (auto &attribute_name: attribute_names) { + mqtt_topics.push_back({get_cred_attribute_mqtt_topic(user_id, + credential_type, + credential_slot, + attribute_name), + ""}); + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); + } +} + +void mock_deletion_cred_rule_mqtt_topic(user_credential_type_t credential_type) +{ + // WARNING : Order here matters based on their initialization order in the add_complete_credential function + std::vector attribute_names = {"LearnSupport", + "SupportedSlotCount", + "CredentialMinLength", + "CredentialMaxLength", + "LearnRecommendedTimeout", + "LearnNumberOfSteps"}; + for (auto &attribute_name: attribute_names) { + mqtt_topics.push_back( + {get_cred_rule_mqtt_topic(credential_type, attribute_name), ""}); + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); + } +} +///////////////////////////////////////////////////////////////////////// +// Capabilities Helper +///////////////////////////////////////////////////////////////////////// +void setup_user_capabilities() { + uint16_t number_of_users = 12; + user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; + uint8_t username_max_length = 112; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 0xFF; + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(NUMBER_OF_USERS), + &number_of_users, + sizeof(number_of_users)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), + &cred_rule_bitmask, + sizeof(cred_rule_bitmask)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(MAX_USERNAME_LENGTH), + &username_max_length, + sizeof(username_max_length)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORT_USER_SCHEDULE), + &support_user_schedule, + sizeof(support_user_schedule)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), + &support_all_users_checksum, + sizeof(support_all_users_checksum)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORT_USER_CHECKSUM), + &support_user_checksum, + sizeof(support_user_checksum)); + + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORTED_USER_TYPES), + &supported_user_types_bitmask, + sizeof(supported_user_types_bitmask)); +} + +void setup_cred_capabilities() { + + // Supports ZCL_CRED_TYPE_PIN_CODE..ZCL_CRED_TYPE_UWB + // Adjust if needed, we don't need to test all types and this outputs a lot of noise on the logs + uint8_t max_cred_type = ZCL_CRED_TYPE_UWB; + for (uint8_t i=ZCL_CRED_TYPE_PIN_CODE;i<=max_cred_type;i++) { + user_credential_type_t cred_type + = static_cast(i); + + auto supported_cred_type_node + = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + &cred_type, + sizeof(cred_type)); + uint8_t crb_support = 1; + uint16_t slot_supported = 0xFFFF; + uint16_t cred_min_length = 0; + uint16_t cred_max_length = 0xFF; + uint8_t learn_timeout = 112; + uint8_t learn_steps = 12; + + mock_expected_cred_rule_mqtt_topic(cred_type, + "LearnSupport", + (bool)crb_support); + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), + &crb_support, + sizeof(crb_support)); + + mock_expected_cred_rule_mqtt_topic(cred_type, + "SupportedSlotCount", + slot_supported); + + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), + &slot_supported, + sizeof(slot_supported)); + mock_expected_cred_rule_mqtt_topic(cred_type, + "CredentialMinLength", + cred_min_length); + + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_MIN_LENGTH), + &cred_min_length, + sizeof(cred_min_length)); + + mock_expected_cred_rule_mqtt_topic(cred_type, + "CredentialMaxLength", + cred_max_length); + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_MAX_LENGTH), + &cred_max_length, + sizeof(cred_max_length)); + + mock_expected_cred_rule_mqtt_topic(cred_type, + "LearnRecommendedTimeout", + learn_timeout); + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + &learn_timeout, + sizeof(learn_timeout)); + + mock_expected_cred_rule_mqtt_topic(cred_type, + "LearnNumberOfSteps", + learn_steps); + attribute_store_emplace(supported_cred_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), + &learn_steps, + sizeof(learn_steps)); + + + // Will allow to test deletion of attributes + created_supported_credential_types.push_back(cred_type); + } +} + +///////////////////////////////////////////////////////////////////////// +// HELPERS +///////////////////////////////////////////////////////////////////////// +extern "C" { + +void helper_test_operation_type(attribute_store_node_t parent_node, + user_credential_operation_type_t operation_type) +{ + attribute_store_type_t tested_attribute_type = ATTRIBUTE(USER_OPERATION_TYPE); + // If we are testing a credential we test its attribute instead + if (attribute_store_get_node_type(parent_node) != ATTRIBUTE(USER_UNIQUE_ID)) { + tested_attribute_type = ATTRIBUTE(CREDENTIAL_OPERATION_TYPE); + } + attribute_store_node_t operation_type_node + = attribute_store_get_first_child_by_type(parent_node, + tested_attribute_type); + user_credential_operation_type_t reported_operation_type; + attribute_store_get_desired(operation_type_node, + &reported_operation_type, + sizeof(reported_operation_type)); + + TEST_ASSERT_EQUAL_MESSAGE(operation_type, + reported_operation_type, + "Operation Type mismatch"); +} + +attribute_store_node_t + helper_add_user_id(user_credential_user_unique_id_t user_unique_id) +{ + return attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_unique_id, + sizeof(user_unique_id)); +} + +// This function will test the MQTT topics for an user +attribute_store_node_t helper_add_complete_user( + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) +{ + attribute_store_node_t user_id_node = helper_add_user_id(user_id); + + mock_expected_user_mqtt_topic(user_id, + "UserType", + user_type_enum_get_enum_value_name(user_type)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_TYPE), + &user_type, + sizeof(user_type)); + + mock_expected_user_mqtt_topic(user_id, + "CredentialRule", + cred_rule_get_enum_value_name(credential_rule)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE), + &credential_rule, + sizeof(credential_rule)); + + mock_expected_user_mqtt_topic(user_id, + "UserActiveState", + static_cast(user_active_state)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE), + &user_active_state, + sizeof(user_active_state)); + + mock_expected_user_mqtt_topic(user_id, + "ExpiringTimeoutMinutes", + static_cast(expiring_timeout)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); + + + mock_expected_user_mqtt_topic( + user_id, + "UserNameEncoding", + user_name_encoding_type_get_enum_value_name(user_name_encoding)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + &user_name_encoding, + sizeof(user_name_encoding)); + + std::string cpp_str_username(user_name); + mock_expected_user_mqtt_topic(user_id, "UserName", cpp_str_username); + attribute_store_node_t user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); + attribute_store_set_reported_string(user_name_node, user_name); + + // Reported attributes by the end device + // Need those to test MQTT topics + user_credential_user_modifier_node_id_t modifier_node_id = 1212; + user_credential_user_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_LOCALLY; + mock_expected_user_mqtt_topic(user_id, + "UserModifierNodeId", + static_cast(modifier_node_id)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_MODIFIER_NODE_ID), + &modifier_node_id, + sizeof(modifier_node_id)); + mock_expected_user_mqtt_topic(user_id, + "UserModifierType", + user_modifier_type_get_enum_value_name(modifier_type)); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_MODIFIER_TYPE), + &modifier_type, + sizeof(modifier_type)); + + // Cleanup : this will automatically test the MQTT deletion messages + created_user_id.push_back(user_id); + + return user_id_node; +} + +// This function will test the MQTT topics for a credential +attribute_store_node_t + helper_add_complete_credential(user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) +{ + attribute_store_node_t user_id_node = helper_add_user_id(user_id); + + attribute_store_node_t credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + attribute_store_node_t credential_slot_node + = attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + std::vector credential_data_vector; + std::string cpp_str_credential_data(credential_data); + + if (credential_type == ZCL_CRED_TYPE_PASSWORD) { + std::wstring_convert, char16_t> cnv; + std::u16string credential_data_utf16 + = cnv.from_bytes(cpp_str_credential_data); + + for (const auto &c: credential_data_utf16) { + credential_data_vector.push_back((uint8_t)(c >> 8)); + credential_data_vector.push_back((uint8_t)c); + } + } else { + credential_data_vector + = std::vector(cpp_str_credential_data.begin(), + cpp_str_credential_data.end()); + } + + uint8_t credential_data_length = credential_data_vector.size(); + attribute_store_node_t credential_data_length_node + = attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &credential_data_length, + sizeof(credential_data_length)); + + mock_expected_cred_mqtt_topic( + user_id, + credential_type, + credential_slot, + "CredentialData", + // Credential data is published in UTF-8 no matter what the encoding is + cpp_str_credential_data); + attribute_store_emplace(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector.data(), + credential_data_vector.size()); + + // Generated by end device + user_credential_modifier_node_id_t modifier_node_id = 1212; + user_credential_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_DNE; + + mock_expected_cred_mqtt_topic(user_id, + credential_type, + credential_slot, + "CredentialModifierNodeId", + static_cast(modifier_node_id)); + attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), + &modifier_node_id, + sizeof(modifier_node_id)); + mock_expected_cred_mqtt_topic(user_id, + credential_type, + credential_slot, + "CredentialModifierType", + user_modifier_type_get_enum_value_name(modifier_type)); + attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + &modifier_type, + sizeof(modifier_type)); + + // Cleanup : this will automatically test the MQTT deletion messages + created_credential_ids.push_back({user_id, credential_type, credential_slot}); + + return user_id_node; +} + +void helper_test_desired_user_attributes( + attribute_store_node_t user_id_node, + UserTypeEnum user_type, + bool user_active_state, + CredRule credential_rule, + const char *user_name, + UserNameEncodingType user_name_encoding, + uint16_t expiring_timeout) +{ + // User Type + attribute_store_node_t user_type_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_TYPE)); + user_credential_type_t reported_user_type; + attribute_store_get_desired(user_type_node, + &reported_user_type, + sizeof(reported_user_type)); + TEST_ASSERT_EQUAL_MESSAGE(user_type, + reported_user_type, + "User Type mismatch"); + + // User Active State + attribute_store_node_t user_active_state_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE)); + user_credential_user_active_state_t reported_user_active_state; + attribute_store_get_desired(user_active_state_node, + &reported_user_active_state, + sizeof(reported_user_active_state)); + TEST_ASSERT_EQUAL_MESSAGE(user_active_state, + reported_user_active_state, + "User Active State mismatch"); + // Credential rule + attribute_store_node_t credential_rule_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE)); + user_credential_rule_t reported_credential_rule; + attribute_store_get_desired(credential_rule_node, + &reported_credential_rule, + sizeof(reported_credential_rule)); + TEST_ASSERT_EQUAL_MESSAGE(credential_rule, + reported_credential_rule, + "Credential Rule mismatch"); + + // User Name + attribute_store_node_t user_name_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_NAME)); + char reported_user_name[255]; + attribute_store_get_desired_string(user_name_node, reported_user_name, 255); + TEST_ASSERT_EQUAL_STRING_MESSAGE(user_name, + reported_user_name, + "User Name mismatch"); + + // User Name Encoding + attribute_store_node_t user_name_encoding_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING)); + user_credential_user_name_encoding_t reported_user_name_encoding; + attribute_store_get_desired(user_name_encoding_node, + &reported_user_name_encoding, + sizeof(reported_user_name_encoding)); + TEST_ASSERT_EQUAL_MESSAGE(user_name_encoding, + reported_user_name_encoding, + "User Name Encoding mismatch"); + + // Expiring Timeout + attribute_store_node_t expiring_timeout_node + = attribute_store_get_first_child_by_type( + user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)); + user_credential_expiring_timeout_minutes_t reported_expiring_timeout; + attribute_store_get_desired(expiring_timeout_node, + &reported_expiring_timeout, + sizeof(reported_expiring_timeout)); + TEST_ASSERT_EQUAL_MESSAGE(expiring_timeout, + reported_expiring_timeout, + "Expiring Timeout mismatch"); +} + +void helper_test_desired_credential_attributes( + user_credential_user_unique_id_t user_id_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data, + bool desired_credential_identifiers, + user_credential_operation_type_t credential_operation_type) +{ + attribute_store_node_value_state_t credential_identifier_state + = desired_credential_identifiers ? DESIRED_ATTRIBUTE : REPORTED_ATTRIBUTE; + + // Credential type + attribute_store_node_t credential_type_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + user_credential_type_t reported_credential_type; + attribute_store_read_value(credential_type_node, + credential_identifier_state, + &reported_credential_type, + sizeof(reported_credential_type)); + TEST_ASSERT_EQUAL_MESSAGE(credential_type, + reported_credential_type, + "Credential Type mismatch"); + + // Credential Slot + attribute_store_node_t credential_slot_node + = attribute_store_get_first_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + user_credential_slot_t reported_credential_slot; + attribute_store_read_value(credential_slot_node, + credential_identifier_state, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(credential_slot, + reported_credential_slot, + "Credential Slot mismatch"); + + uint8_t expected_data_length; + std::vector expected_credential_data_vector; + std::string str_credential_data(credential_data); + + // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + if (credential_type == ZCL_CRED_TYPE_PASSWORD) { + std::wstring_convert, char16_t> cnv; + std::u16string utf16_cred_data = cnv.from_bytes(str_credential_data); + if (cnv.converted() < str_credential_data.size()) + TEST_FAIL_MESSAGE("Can't convert password to utf-16"); + + for (const auto &c: utf16_cred_data) { + expected_credential_data_vector.push_back((uint8_t)(c >> 8)); + expected_credential_data_vector.push_back((uint8_t)c); + } + expected_data_length = expected_credential_data_vector.size(); + } else { + expected_data_length = str_credential_data.size(); + expected_credential_data_vector + = std::vector(str_credential_data.begin(), + str_credential_data.end()); + } + // Credential Data Length + attribute_store_node_t credential_data_length_node + = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + uint8_t reported_credential_data_length; + attribute_store_get_desired(credential_data_length_node, + &reported_credential_data_length, + sizeof(reported_credential_data_length)); + TEST_ASSERT_EQUAL_MESSAGE(expected_data_length, + reported_credential_data_length, + "Credential Data Length mismatch"); + + // Credential Data + attribute_store_node_t credential_data_node + = attribute_store_get_first_child_by_type(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA)); + std::vector reported_credential_data; + reported_credential_data.resize(reported_credential_data_length); + attribute_store_get_desired(credential_data_node, + reported_credential_data.data(), + reported_credential_data_length); + + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_credential_data_vector.data(), + reported_credential_data.data(), + expected_credential_data_vector.size(), + "Credential Data mismatch"); + + // Operation type + helper_test_operation_type(credential_slot_node, credential_operation_type); +} + +void helper_test_user_id(attribute_store_node_t user_id_node, + user_credential_user_unique_id_t user_unique_id, + attribute_store_node_value_state_t value_state) +{ + user_credential_user_unique_id_t reported_user_id; + attribute_store_read_value(user_id_node, + value_state, + &reported_user_id, + sizeof(reported_user_id)); + TEST_ASSERT_EQUAL_MESSAGE(user_unique_id, + reported_user_id, + "User ID mismatch"); +} + +///////////////////////////////////////////////////////////////////////// +// Test cases +///////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////// +// Add user +/////////////////////////////////////////////////// +void test_user_credential_cluster_add_user_not_supported() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_PROGRAMMING_USER; + CredRule credential_rule = ZCL_CRED_RULE_DUAL; + bool user_active_state = false; + uint16_t expiring_timeout = 0; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_UTF_16; + const char *user_name = "V16 TUNING PRO MAX"; + + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + 0, // User ID 0 is reserved + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 0 is reserved so it should " + "return SL_STATUS_FAIL"); + + // Simulate user + helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 12 is existing so it should return SL_STATUS_FAIL"); +} + +void test_user_credential_cluster_add_user_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_PROGRAMMING_USER; + CredRule credential_rule = ZCL_CRED_RULE_DUAL; + bool user_active_state = false; + uint16_t expiring_timeout = 0; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_UTF_16; + const char *user_name = "ENDIVE BOOSTER TURBO MAX"; + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + add_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 12 is not existing so it should return SL_STATUS_OK"); + + // Test attribute tree state + // All attributes should be set as desired + // User ID + attribute_store_node_t user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + helper_test_user_id(user_id_node, user_unique_id, DESIRED_ATTRIBUTE); + helper_test_desired_user_attributes(user_id_node, + user_type, + user_active_state, + credential_rule, + user_name, + user_name_encoding, + expiring_timeout); + + helper_test_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); +} + +/////////////////////////////////////////////////// +// Modify user +/////////////////////////////////////////////////// +void test_user_credential_cluster_modify_user_not_supported() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_PROGRAMMING_USER; + CredRule credential_rule = ZCL_CRED_RULE_DUAL; + bool user_active_state = false; + uint16_t expiring_timeout = 0; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_UTF_16; + const char *user_name = "VROUM VROUM"; + + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 12 doesn't exists so it should return SL_STATUS_FAIL"); +} + +void test_user_credential_cluster_modify_user_with_expiring_timeout() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_EXPIRING_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "TURBO MAX CANON"; + // Since we are updating to a ZCL_USER_TYPE_ENUM_DISPOSABLE_USER, expiring_timeout should not be updated + attribute_store_node_t user_id_node + = helper_add_complete_user(user_unique_id, + ZCL_USER_TYPE_ENUM_DISPOSABLE_USER, + ZCL_CRED_RULE_TRIPLE, + user_active_state, + expiring_timeout, + user_name_encoding, + "DEFINITELY NOT TURBO"); + + // Execute command + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 12 exists so it should return SL_STATUS_OK"); + + // Test attribute tree state + // All attributes should be set as desired except for user id + helper_test_user_id(user_id_node, user_unique_id, REPORTED_ATTRIBUTE); + helper_test_desired_user_attributes(user_id_node, + user_type, + user_active_state, + credential_rule, + user_name, + user_name_encoding, + expiring_timeout); + helper_test_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +void test_user_credential_cluster_modify_user_without_expiring_timeout() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_DISPOSABLE_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "Test User"; + + attribute_store_node_t user_id_node + = helper_add_complete_user(user_unique_id, + ZCL_USER_TYPE_ENUM_EXPIRING_USER, + ZCL_CRED_RULE_DUAL, + user_active_state, + 0, + user_name_encoding, + "Test User Original"); + + // Force timeout attribute to 0 and we'll check if that has moved or not + expiring_timeout = 0; + attribute_store_set_child_desired(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); + // Execute command + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "User 12 exists so it should return SL_STATUS_OK"); + + // Test attribute tree state + // All attributes should be set as desired except for user id + helper_test_user_id(user_id_node, user_unique_id, REPORTED_ATTRIBUTE); + helper_test_desired_user_attributes( + user_id_node, + user_type, + user_active_state, + credential_rule, + user_name, + user_name_encoding, + // Force to 0 here since it should not be modified + 0); + helper_test_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +/////////////////////////////////////////////////// +// Delete user +/////////////////////////////////////////////////// + +void test_user_credential_cluster_delete_user_not_supported() +{ + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + delete_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + 12), + "User 12 doesn't exists so it should return SL_STATUS_FAIL"); +} + +void test_user_credential_cluster_delete_user_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_EXPIRING_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "RIP JACKIE TUNNING"; + + auto user_unique_id_node = helper_add_complete_user(user_unique_id, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id), + "Should be able to mark user 12 for deletion"); + + helper_test_operation_type(user_unique_id_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + +/////////////////////////////////////////////////// +// Add credential +/////////////////////////////////////////////////// +void test_user_credential_cluster_add_credential_not_supported() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, // Non existing user + CredType::ZCL_CRED_TYPE_BLE, + 1, + "Test Credential"), + "User 12 is not existing so it should return SL_STATUS_FAIL"); + + // Simulate user + helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + static_cast(0), // Reserved + 1, + "Test Credential"), + "Credential type 0 is reserved so it should return SL_STATUS_FAIL"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + CredType::ZCL_CRED_TYPE_PIN_CODE, + 0, // Reserved + "Test Credential"), + "Credential slot 0 is reserved so it should return SL_STATUS_FAIL"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + CredType::ZCL_CRED_TYPE_PIN_CODE, + 1, + "1234567ABCDEF"), + "PINCode contains invalid char, it should return SL_STATUS_FAIL"); +} + +void test_user_credential_cluster_add_credential_pin_code_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + const char *credential_data = "123456789"; + + // Add simple user + helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data), + "Should be able to add a new credential"); + + // Test attribute tree state + // All attributes should be set as desired + // User ID + attribute_store_node_t user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + helper_test_user_id(user_id_node, user_unique_id, REPORTED_ATTRIBUTE); + helper_test_desired_credential_attributes(user_id_node, + credential_type, + credential_slot, + credential_data, + true, + USER_CREDENTIAL_OPERATION_TYPE_ADD); +} + +void test_user_credential_cluster_add_credential_password_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PASSWORD; + user_credential_slot_t credential_slot = 1; + const char *credential_data = "hunter2"; + + // Add simple user + helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data), + "Should be able to add a new credential"); + + // Test attribute tree state + // All attributes should be set as desired + // User ID + attribute_store_node_t user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + helper_test_user_id(user_id_node, user_unique_id, REPORTED_ATTRIBUTE); + helper_test_desired_credential_attributes(user_id_node, + credential_type, + credential_slot, + credential_data, + true, + USER_CREDENTIAL_OPERATION_TYPE_ADD); +} + +void test_user_credential_cluster_add_credential_others_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_NFC; + user_credential_slot_t credential_slot = 1; + const char *credential_data = "hunter2"; + + // Add simple user + helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + add_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data), + "Should be able to add a new credential"); + + // Test attribute tree state + // All attributes should be set as desired + // User ID + attribute_store_node_t user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + helper_test_user_id(user_id_node, user_unique_id, REPORTED_ATTRIBUTE); + helper_test_desired_credential_attributes(user_id_node, + credential_type, + credential_slot, + credential_data, + true, + USER_CREDENTIAL_OPERATION_TYPE_ADD); +} + +/////////////////////////////////////////////////// +// Modify credential +/////////////////////////////////////////////////// +void test_user_credential_cluster_modify_credential_not_supported() +{ + // Simulate Credential + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, // Non existing user + credential_type, + credential_slot, + ""), + "User 12 doesn't exists so it should return SL_STATUS_FAIL"); + + // Simulate user + auto user_id_node = helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + ""), + "Credential type doesn't exists so it should return SL_STATUS_FAIL"); + + user_credential_type_t credential_type_c + = static_cast(credential_type); + auto credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type_c, + sizeof(credential_type_c)); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + ""), + "Credential slot doesn't exists so it should return SL_STATUS_FAIL"); + + attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + CredType::ZCL_CRED_TYPE_PIN_CODE, + 1, + "1234567ABCDEF"), + "PINCode contains invalid char, it should return SL_STATUS_FAIL"); +} + +void test_user_credential_cluster_modify_credential_pin_code_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + std::string credential_data = "123456789"; + + auto user_id_node = helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()); + + credential_data = "12"; + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()), + "Should be able to modify a credential"); + + helper_test_desired_credential_attributes( + user_id_node, + credential_type, + credential_slot, + credential_data.c_str(), + false, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +void test_user_credential_cluster_modify_credential_password_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PASSWORD; + user_credential_slot_t credential_slot = 12; + std::string credential_data = "hunter2"; + + auto user_id_node = helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()); + // Test UTF-16 conversion for password + credential_data = "🔥MAX SPEED TURBO🔥"; + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()), + "Should be able to modify a credential"); + + helper_test_desired_credential_attributes( + user_id_node, + credential_type, + credential_slot, + credential_data.c_str(), + false, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +void test_user_credential_cluster_modify_credential_others_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_BLE; + user_credential_slot_t credential_slot = 2; + std::string credential_data = "FAST TURBO ENGINE DOG PRO MAX"; + + auto user_id_node = helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()); + // Test UTF-16 conversion for password + credential_data = "FAE124A54E5F9325874A23E3646B"; + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()), + "Should be able to modify a credential"); + + helper_test_desired_credential_attributes( + user_id_node, + credential_type, + credential_slot, + credential_data.c_str(), + false, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +/////////////////////////////////////////////////// +// Delete credential +/////////////////////////////////////////////////// +void test_user_credential_cluster_delete_credential_not_supported() +{ + // Simulate Credential + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + + // Support check + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + delete_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, // Non existing user + credential_type, + credential_slot), + "User 12 doesn't exists so it should return SL_STATUS_FAIL"); + + // Simulate user + auto user_id_node = helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + delete_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot), + "Credential type doesn't exists so it should return SL_STATUS_FAIL"); + + user_credential_type_t credential_type_c + = static_cast(credential_type); + auto credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type_c, + sizeof(credential_type_c)); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + delete_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot), + "Credential slot doesn't exists so it should return SL_STATUS_FAIL"); + + attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); +} + +void test_user_credential_cluster_delete_credential_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + CredType credential_type = CredType::ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + std::string credential_data = "12121212"; + + auto user_id_node = helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + credential_data.c_str()); + + auto credential_type_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + auto credential_slot_node + = attribute_store_get_first_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_credential_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + credential_type, + credential_slot), + "Should be able to mark credential for deletion"); + + helper_test_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + +/////////////////////////////////////////////////// +// Support tests +/////////////////////////////////////////////////// + +void test_user_credential_cluster_test_user_command_support_happy_case() +{ + // Emplace checked attributes + uint16_t user_count = 2; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(NUMBER_OF_USERS), + &user_count, + sizeof(user_count)); + + // We don't care about those value it should not matter here + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_DISPOSABLE_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "Test User"; + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + add_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "Add user should be supported"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + modify_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "Modify user should be supported"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id), + "Delete user should be supported"); +} + +void test_user_credential_cluster_test_user_command_not_supported_happy_case() +{ + // We don't care about those value it should not matter here + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_DISPOSABLE_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "Test User"; + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + add_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "Add user should not be supported"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + modify_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id, + user_type, + user_active_state, + credential_rule, + user_name, + expiring_timeout, + user_name_encoding), + "Modify user should not be supported"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + delete_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + user_unique_id), + "Delete user should not be supported"); +} + +} // extern "C" \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/test/workaround_for_test.hpp b/applications/zpc/components/zcl_cluster_servers/test/workaround_for_test.hpp new file mode 100644 index 000000000..e2b85fb10 --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/test/workaround_for_test.hpp @@ -0,0 +1,25 @@ +#ifndef WORKAROUND_FOR_TEST_HPP +#define WORKAROUND_FOR_TEST_HPP + +/* This is a workaround to hide the C++ includes from + * Unity's generate_test_runner.rb +*/ + +#ifdef __cplusplus +#include +#include +#include +#include + +#include +#include +#include + +// UTF16 conversion (deprecated in C++17) +// Needed for credential data (password) per specification +#include +#include + +#include "dotdot_mqtt_helpers.hpp" +#endif +#endif diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index c7b14cbe5..fd3df4577 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -68,6 +68,11 @@ typedef uint16_t user_credential_slot_t; #define USER_CREDENTIAL_OPERATION_TYPE_DELETE 0x02 typedef uint8_t user_credential_operation_type_t; +///> Credential Modifier Type. uint8_t +typedef uint8_t user_credential_modifier_type_t; +///> Credential Modifier Node ID. uint16_t +typedef uint16_t user_credential_modifier_node_id_t; + ///> Expiring Timeout for User (Minutes). uint16_t typedef uint16_t user_credential_expiring_timeout_minutes_t; diff --git a/applications/zpc/components/zwave_command_classes/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/CMakeLists.txt index b5d545e0e..c1ee84ed2 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -135,6 +135,9 @@ if(BUILD_TESTING) # Mocks target_add_mock(zwave_command_classes) + add_mock(zwave_command_class_notification_mock src/zwave_command_class_notification.h) + target_interface_libraries(zwave_command_class_notification_mock zpc_utils zwave_command_handler) + # Unit test subdirectory add_subdirectory(test) endif() diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 5a3810ae0..02ea0ecfa 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -16,10 +16,11 @@ #include #include "zwave_command_class_user_credential.h" -#include "zwave_command_class_user_credential_types.h" #include "zwave_command_classes_utils.h" #include "ZW_classcmd.h" +#include "zwave_command_class_notification.h" + // Includes from other ZPC Components #include "zwave_command_class_indices.h" #include "zwave_command_handler.h" @@ -40,6 +41,12 @@ // Cpp related #include #include +#include + +// UTF16 conversion (deprecated in C++17) +// Needed for credential data (password) per specification +#include +#include // Macro #define LOG_TAG "zwave_command_class_user_credential" @@ -127,10 +134,54 @@ std::string get_string_value(const uint8_t *frame_data, return value; } +/////////////////////////////////////////////////////////////////////// +// Mics helpers +/////////////////////////////////////////////////////////////////////// +std::u16string utf8_to_utf16(const std::string &utf8) +{ + std::wstring_convert, char16_t> cnv; + std::u16string s = cnv.from_bytes(utf8); + if (cnv.converted() < utf8.size()) + throw std::runtime_error("incomplete conversion"); + return s; +} + ///////////////////////////////////////////////////////////////////////////// // Command Class Helper ///////////////////////////////////////////////////////////////////////////// +void set_operation_type(attribute_store_node_t node, + attribute_store_type_t operation_type_node_type, + user_credential_operation_type_t operation_type) +{ + auto operation_type_node + = attribute_store_get_node_child_by_type(node, operation_type_node_type, 0); + + if (!attribute_store_node_exists(operation_type_node)) { + operation_type_node + = attribute_store_add_node(operation_type_node_type, node); + } + // Undefine reported to be sure that we can so the same operation twice in a row + attribute_store_undefine_reported(operation_type_node); + attribute_store_set_desired(operation_type_node, + &operation_type, + sizeof(operation_type)); +} +void set_user_operation_type(attribute_store_node_t user_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(user_node, ATTRIBUTE(USER_OPERATION_TYPE), operation_type); +} + +void set_credential_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type); +} + /** * @brief Get user id node * @@ -193,7 +244,7 @@ attribute_store_node_t */ attribute_store_node_t get_desired_user_id_node(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) + user_credential_user_unique_id_t user_id) { attribute_store_node_t user_id_node; get_user_id_node(endpoint_node, user_id, DESIRED_ATTRIBUTE, user_id_node); @@ -472,6 +523,634 @@ sl_status_t return SL_STATUS_OK; } +/** + * @brief Updates the desired values of attributes in the attribute store. + * + * This function takes a map of attribute values and their corresponding sizes, and updates the desired values + * of the attributes in the attribute store. + * The attribute store is updated for the specified parent node. + * + * @param attribute_map_values A map containing the attribute values and their sizes. + * @param parent_node The parent node of values that will be updated + * + * @return SL_STATUS_OK if the desired values were updated successfully, an otherwise an error code. + */ +sl_status_t update_desired_values( + attribute_store_node_t parent_node, + std::map> + attribute_map_values) +{ + sl_status_t status = SL_STATUS_OK; + for (auto &attr: attribute_map_values) { + auto value = attr.second.first; + auto value_size = attr.second.second; + + if (attribute_store_get_storage_type(attr.first) == C_STRING_STORAGE_TYPE) { + auto str_attribute_node + = attribute_store_get_node_child_by_type(parent_node, attr.first, 0); + auto value_str = static_cast(value); + sl_log_debug(LOG_TAG, + "Update desired value of %s to %s", + attribute_store_get_type_name(attr.first), + value_str); + status + |= attribute_store_set_desired_string(str_attribute_node, value_str); + } else { + sl_log_debug(LOG_TAG, + "Update desired value of %s", + attribute_store_get_type_name(attr.first)); + status |= attribute_store_set_child_desired(parent_node, + attr.first, + value, + value_size); + } + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Error while setting desired value of %s", + attribute_store_get_type_name(attr.first)); + } + } + + return status; +} + +///////////////////////////////////////////////////////////////////////////// +// Notification callback +///////////////////////////////////////////////////////////////////////////// + +namespace notification_handler +{ +namespace user +{ +// Indexes +// User Notification Report Frame +constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 2; +constexpr uint8_t INDEX_USER_MODIFIER_NODE_ID = 3; +constexpr uint8_t INDEX_USER_UNIQUE_ID = 5; +constexpr uint8_t INDEX_USER_TYPE = 7; +constexpr uint8_t INDEX_USER_ACTIVE_STATE = 8; +constexpr uint8_t INDEX_USER_CREDENTIAL_RULE = 9; +constexpr uint8_t INDEX_USER_EXPIRING_TIMEOUT_MINUTES = 10; +constexpr uint8_t USER_NOTIFICATION_REPORT_FRAME_LENGTH + = INDEX_USER_EXPIRING_TIMEOUT_MINUTES + 2; + +// Constains the indexes mapped of the User Notification Report +const std::vector user_notification_report_data + = {{ATTRIBUTE(USER_MODIFIER_TYPE), INDEX_USER_MODIFIER_TYPE}, + {ATTRIBUTE(USER_MODIFIER_NODE_ID), INDEX_USER_MODIFIER_NODE_ID}, + {ATTRIBUTE(USER_TYPE), INDEX_USER_TYPE}, + {ATTRIBUTE(USER_ACTIVE_STATE), + INDEX_USER_ACTIVE_STATE, + USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK}, + {ATTRIBUTE(CREDENTIAL_RULE), INDEX_USER_CREDENTIAL_RULE}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + INDEX_USER_EXPIRING_TIMEOUT_MINUTES}}; + +// Contains all the user data attributes +const std::vector user_data_attribute_types + = {ATTRIBUTE(USER_MODIFIER_TYPE), + ATTRIBUTE(USER_MODIFIER_NODE_ID), + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME)}; + +user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) +{ + return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); +} + +user_credential_user_modifier_type_t + get_user_modifier_type(const uint8_t *event_parameters) +{ + return event_parameters[INDEX_USER_MODIFIER_TYPE]; +} +// Get user node reported in the notification parameters +attribute_store_node_t get_user_node(attribute_store_node_t endpoint_node, + const uint8_t *event_parameters, + attribute_store_node_value_state_t state) +{ + user_credential_user_unique_id_t user_id + = get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); + + attribute_store_node_t user_node + = (state == REPORTED_ATTRIBUTE) + ? get_reported_user_id_node(endpoint_node, user_id) + : get_desired_user_id_node(endpoint_node, user_id); + + if (user_node == ATTRIBUTE_STORE_INVALID_NODE) { + sl_log_debug(LOG_TAG, + "Can't find user %d present in Notification Parameters", + user_id); + } + return user_node; +} + +void update_user_reported_values(attribute_store_node_t user_id_node, + const uint8_t *event_parameters) +{ + sl_status_t set_status + = set_reported_attributes(user_id_node, + event_parameters, + user_notification_report_data); + + if (set_status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Error while setting reported attributes"); + } + + // Those are not present in the User Notification command, we assume they stay the same + // FIXME: https://github.com/Z-Wave-Alliance/AWG/issues/168 + auto user_name_encoding_node + = attribute_store_get_node_child_by_type(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + 0); + attribute_store_set_reported_as_desired(user_name_encoding_node); + auto user_name_node + = attribute_store_get_node_child_by_type(user_id_node, + ATTRIBUTE(USER_NAME), + 0); + attribute_store_set_reported_as_desired(user_name_node); +}; + +bool is_report_size_conform(uint8_t event_parameters_length) +{ + if (event_parameters_length != USER_NOTIFICATION_REPORT_FRAME_LENGTH) { + sl_log_error(LOG_TAG, "Invalid User Notification Report size"); + return false; + } + return true; +}; + +} // namespace user + +namespace credential +{ +// Indexes +// Credential Notification Report Frame +constexpr uint8_t INDEX_USER_UNIQUE_ID = 0; +constexpr uint8_t INDEX_CREDENTIAL_TYPE = 2; +constexpr uint8_t INDEX_CREDENTIAL_SLOT = 3; +constexpr uint8_t INDEX_CREDENTIAL_CRB = 5; +constexpr uint8_t INDEX_CREDENTIAL_LENGTH = 6; +constexpr uint8_t INDEX_CREDENTIAL_DATA = 7; +constexpr uint8_t CREDENTIAL_NOTIFICATION_REPORT_MIN_FRAME_LENGTH + = INDEX_CREDENTIAL_DATA + 3; + +user_credential_type_t get_credential_type(const uint8_t *event_parameters) +{ + return event_parameters[INDEX_CREDENTIAL_TYPE]; +} + +user_credential_slot_t get_credential_slot(const uint8_t *event_parameters) +{ + return get_uint16_value(event_parameters, INDEX_CREDENTIAL_SLOT); +} +user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) +{ + return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); +} + +attribute_store_node_t + get_credential_type_node(attribute_store_node_t endpoint_node, + const uint8_t *event_parameters, + attribute_store_node_value_state_t state) +{ + user_credential_user_unique_id_t user_id + = get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); + user_credential_type_t credential_type + = get_credential_type(event_parameters); + + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + bool credential_type_node_found + = get_credential_type_node(endpoint_node, + user_id, + credential_type, + state, + credential_type_node); + if (!credential_type_node_found) { + sl_log_debug( + LOG_TAG, + "Can't find credential type %d present in Notification Parameters", + credential_type); + } + + return credential_type_node; +} + +attribute_store_node_t + get_credential_slot_node(attribute_store_node_t credential_type_node, + const uint8_t *event_parameters, + attribute_store_node_value_state_t state) +{ + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + user_credential_slot_t credential_slot + = get_credential_slot(event_parameters); + + bool credential_slot_node_found + = get_credential_slot_node(credential_type_node, + credential_slot, + state, + credential_slot_node); + if (!credential_slot_node_found) { + sl_log_debug( + LOG_TAG, + "Can't find credential slot %d present in Notification Parameters", + credential_slot); + } + return credential_slot_node; +} + +bool is_report_size_conform(uint8_t event_parameters_length) +{ + if (event_parameters_length + < CREDENTIAL_NOTIFICATION_REPORT_MIN_FRAME_LENGTH) { + sl_log_error(LOG_TAG, "Invalid Credential Notification Report size"); + return false; + } + + return true; +}; + +void update_credential_reported_values( + attribute_store_node_t credential_slot_node, const uint8_t *event_parameters) +{ + const uint8_t credential_length = event_parameters[INDEX_CREDENTIAL_LENGTH]; + const uint8_t INDEX_CREDENTIAL_MODIFIER_TYPE + = INDEX_CREDENTIAL_DATA + credential_length; + const uint8_t INDEX_CREDENTIAL_MODIFIER_NODE_ID + = INDEX_CREDENTIAL_MODIFIER_TYPE + 1; + + // Set standard (uint8 & uint16) data + std::vector user_data = { + {ATTRIBUTE(CREDENTIAL_READ_BACK), + INDEX_CREDENTIAL_CRB, + CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, + 7}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), INDEX_CREDENTIAL_MODIFIER_TYPE}, + {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), INDEX_CREDENTIAL_MODIFIER_NODE_ID}, + {ATTRIBUTE(CREDENTIAL_DATA_LENGTH), INDEX_CREDENTIAL_LENGTH}, + }; + + sl_status_t status = set_reported_attributes(credential_slot_node, + event_parameters, + user_data); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Error while setting reported attributes"); + return; + } + + auto credential_data_length_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + auto credential_data_node + = attribute_store_get_first_child_by_type(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA)); + + status + = attribute_store_set_reported(credential_data_node, + &event_parameters[INDEX_CREDENTIAL_DATA], + credential_length); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Can't set CREDENTIAL_DATA in attribute store"); + return; + } + attribute_store_undefine_desired(credential_data_node); +}; + +} // namespace credential +} // namespace notification_handler + +void on_notification_event(attribute_store_node_t endpoint_node, + uint8_t notification_type, + uint8_t event_code, + const uint8_t *event_parameters, + uint8_t event_parameters_length) +{ + // We don't care about anything else than access control + if (notification_type != NOTIFICATION_ACCESS_CONTROL) { + return; + } + + auto get_credential_slot_node_by_type = [&]() { + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type(event_parameters); + user_credential_slot_t credential_slot + = notification_handler::credential::get_credential_slot(event_parameters); + user_credential_user_unique_id_t user_id + = notification_handler::credential::get_user_id(event_parameters); + + // Credential type node + attribute_store_node_t credential_type_node + = notification_handler::credential::get_credential_type_node( + endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error(LOG_TAG, + "Didn't find credential type %d (user %d).", + credential_type, + user_id); + return ATTRIBUTE_STORE_INVALID_NODE; + } + + attribute_store_node_t credential_slot_node + = notification_handler::credential::get_credential_slot_node( + credential_type_node, + event_parameters, + REPORTED_ATTRIBUTE); + + if (!attribute_store_node_exists(credential_slot_node)) { + sl_log_error(LOG_TAG, + "Didn't find credential slot %d for credential type %d " + "(user %d).", + credential_slot, + credential_type, + user_id); + return ATTRIBUTE_STORE_INVALID_NODE; + } + + return credential_slot_node; + }; + + // Logic + switch (event_code) { + // User unchanged + case 0x2A: { + sl_log_debug(LOG_TAG, "Notification : User Unchanged"); + if (!notification_handler::user::is_report_size_conform( + event_parameters_length)) { + return; + } + user_credential_user_unique_id_t user_id + = notification_handler::user::get_user_id(event_parameters); + + attribute_store_node_t user_id_node + = notification_handler::user::get_user_node(endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + if (!attribute_store_node_exists(user_id_node)) { + // Check desired value in case the Add operation didn't work + user_id_node + = notification_handler::user::get_user_node(endpoint_node, + event_parameters, + DESIRED_ATTRIBUTE); + + // If still not exists we return an error + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, "Didn't find user ID %d.", user_id); + return; + } + } + + // If user doesn't exists in the device we try to remove it also from our side + user_credential_user_modifier_type_t modifier_type + = notification_handler::user::get_user_modifier_type(event_parameters); + if (modifier_type == USER_REPORT_DNE) { + attribute_store_delete_node(user_id_node); + } else { + sl_log_info(LOG_TAG, "User Unchanged, clearing desired values."); + + for (auto &user_data_type: + notification_handler::user::user_data_attribute_types) { + attribute_store_undefine_desired( + attribute_store_get_node_child_by_type(user_id_node, + user_data_type, + 0)); + } + } + } break; + // User Added + case 0x27: { + sl_log_debug(LOG_TAG, "Notification : User Added"); + + if (!notification_handler::user::is_report_size_conform( + event_parameters_length)) { + return; + } + // User node + attribute_store_node_t user_id_node + = notification_handler::user::get_user_node(endpoint_node, + event_parameters, + DESIRED_ATTRIBUTE); + user_credential_user_unique_id_t user_id + = notification_handler::user::get_user_id(event_parameters); + + // Fallback if we didn't find the user in desired value, we check the reported ones + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Didn't find user ID %d in 'add state' (desired value). " + "Can't add user.", + user_id); + return; + } else { + // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason + attribute_store_undefine_desired(user_id_node); + // If we found the user id, we mark it a reported now. + attribute_store_set_reported(user_id_node, &user_id, sizeof(user_id)); + } + + notification_handler::user::update_user_reported_values(user_id_node, + event_parameters); + + } break; + // User Modified + case 0x28: { + sl_log_debug(LOG_TAG, "Notification : User Modified"); + + if (!notification_handler::user::is_report_size_conform( + event_parameters_length)) { + return; + } + + attribute_store_node_t user_id_node + = notification_handler::user::get_user_node(endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + + if (!attribute_store_node_exists(user_id_node)) { + user_credential_user_unique_id_t user_id + = notification_handler::user::get_user_id(event_parameters); + sl_log_error(LOG_TAG, + "Didn't find user ID %d. Can't modify user.", + user_id); + return; + } + + notification_handler::user::update_user_reported_values(user_id_node, + event_parameters); + + } break; + // User Deleted + case 0x29: { + sl_log_debug(LOG_TAG, "Notification : User Deleted"); + + if (!notification_handler::user::is_report_size_conform( + event_parameters_length)) { + return; + } + + // Get user node so we can remove it + attribute_store_node_t deleted_user_id_node + = notification_handler::user::get_user_node(endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + attribute_store_delete_node(deleted_user_id_node); + } break; + // Credential Added + case 0x2B: { + sl_log_debug(LOG_TAG, "Notification : Credential Added"); + + if (!notification_handler::credential::is_report_size_conform( + event_parameters_length)) { + return; + } + + // Type and slot + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type( + event_parameters); + user_credential_slot_t credential_slot + = notification_handler::credential::get_credential_slot( + event_parameters); + + // Credential type node + attribute_store_node_t credential_type_node + = notification_handler::credential::get_credential_type_node( + endpoint_node, + event_parameters, + DESIRED_ATTRIBUTE); + + // Credential Type might be already present here + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_debug( + LOG_TAG, + "Didn't find credential type %d with desired value, checking " + "reported value.", + credential_type); + credential_type_node + = notification_handler::credential::get_credential_type_node( + endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + // Now this is a real issue, we doesn't update anything + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error(LOG_TAG, + "Didn't find credential type %d. Can't add credential.", + credential_type); + return; + } + } else { + // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason + attribute_store_undefine_desired(credential_type_node); + // If we found the credential we mark it a reported now. + attribute_store_set_reported(credential_type_node, + &credential_type, + sizeof(credential_type)); + } + + // Now we'll check the credential slot + attribute_store_node_t credential_slot_node + = notification_handler::credential::get_credential_slot_node( + credential_type_node, + event_parameters, + DESIRED_ATTRIBUTE); + // This must be in defined state + if (!attribute_store_node_exists(credential_slot_node)) { + sl_log_error(LOG_TAG, + "Didn't find credential slot %d with desired value. Not " + "adding credential", + credential_slot); + return; + } + + // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason + attribute_store_undefine_desired(credential_slot_node); + // If we found the credential we mark it a reported now. + attribute_store_set_reported(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + + notification_handler::credential::update_credential_reported_values( + credential_slot_node, + event_parameters); + + } break; + // Credential Modified + case 0x2C: { + sl_log_debug(LOG_TAG, "Notification : Credential Modified"); + if (!notification_handler::credential::is_report_size_conform( + event_parameters_length)) { + return; + } + + // Used in logs + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type( + event_parameters); + user_credential_slot_t credential_slot + = notification_handler::credential::get_credential_slot( + event_parameters); + user_credential_user_unique_id_t user_id + = notification_handler::credential::get_user_id(event_parameters); + + // Get credential slot + auto credential_slot_node = get_credential_slot_node_by_type(); + if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { + return; + } + + notification_handler::credential::update_credential_reported_values( + credential_slot_node, + event_parameters); + + sl_log_debug(LOG_TAG, + "Credential Modified. Type %d, Slot %d (User %d) ", + credential_type, + credential_slot, + user_id); + } break; + // Credential Deleted + case 0x2D: { + sl_log_debug(LOG_TAG, "Notification : Credential Deleted"); + if (!notification_handler::credential::is_report_size_conform( + event_parameters_length)) { + return; + } + + // Used in logs + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type( + event_parameters); + user_credential_slot_t credential_slot + = notification_handler::credential::get_credential_slot( + event_parameters); + user_credential_user_unique_id_t user_id + = notification_handler::credential::get_user_id(event_parameters); + + // Type and slot + auto credential_slot_node = get_credential_slot_node_by_type(); + if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { + return; + } + attribute_store_delete_node(credential_slot_node); + sl_log_debug(LOG_TAG, + "Credential Deleted. Type %d, Slot %d (User %d) ", + credential_type, + credential_slot, + user_id); + } break; + default: + break; + } +} + ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -505,6 +1184,11 @@ static void zwave_command_class_user_credential_on_version_attribute_update( attribute_store_add_if_missing(endpoint_node, attributes, COUNT_OF(attributes)); + + // Listen to + zwave_command_class_notification_register_event_callback( + endpoint_node, + &on_notification_event); } ///////////////////////////////////////////////////////////////////////////// @@ -680,11 +1364,15 @@ sl_status_t attribute_store_delete_node(type_node); } while (type_node != ATTRIBUTE_STORE_INVALID_NODE); + uint16_t ucl_credential_type_mask = 0; + uint16_t current_index = 4; for (uint8_t i = 0; i < supported_credential_types_count; i++) { // > Root node : Credential Type user_credential_type_t credential_type = frame_data[current_index]; + ucl_credential_type_mask |= (1 << (credential_type - 1)); + attribute_store_node_t credential_type_node = attribute_store_emplace(endpoint_node, ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), @@ -737,6 +1425,13 @@ sl_status_t current_index++; } + // Set UCL mask for supported user credential types + attribute_store_set_child_reported( + endpoint_node, + DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, + &ucl_credential_type_mask, + sizeof(ucl_credential_type_mask)); + return SL_STATUS_OK; } @@ -845,6 +1540,7 @@ static sl_status_t zwave_command_class_user_credential_credential_set( attribute_store_node_t user_unique_id_node = attribute_store_get_first_parent_with_type(credential_type_node, ATTRIBUTE(USER_UNIQUE_ID)); + // Since CREDENTIAL_DATA is not directly under credential_slot_node we need to fetch it first attribute_store_node_t credential_length_node = attribute_store_get_first_child_by_type( @@ -1042,7 +1738,11 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( attribute_store_node_t slot_node_0; // Get nodes 0 - get_credential_type_node(endpoint_node, user_id, 0, REPORTED_ATTRIBUTE, type_node_0); + get_credential_type_node(endpoint_node, + user_id, + 0, + REPORTED_ATTRIBUTE, + type_node_0); get_credential_slot_node(type_node_0, 0, DESIRED_ATTRIBUTE, slot_node_0); // Remove them @@ -1259,8 +1959,6 @@ static sl_status_t zwave_command_class_user_credential_user_set( &user_id, sizeof(user_id)); - sl_log_debug(LOG_TAG, "User SET for user %d", user_id); - // If we can't get the user unique id we can't continue if (!attribute_store_node_exists(user_unique_id_node)) { return SL_STATUS_NOT_SUPPORTED; @@ -1268,19 +1966,25 @@ static sl_status_t zwave_command_class_user_credential_user_set( user_credential_operation_type_t user_operation_type = 0; sl_status_t status = attribute_store_get_desired(user_operation_type_node, - &user_operation_type, - sizeof(user_operation_type)); + &user_operation_type, + sizeof(user_operation_type)); + + sl_log_debug(LOG_TAG, + "User SET for user %d (operation type : %d)", + user_id, + user_operation_type); - if (status != SL_STATUS_OK) { + if (status != SL_STATUS_OK) { sl_log_error(LOG_TAG, "Can't get user operation type value. Not sending USER_SET."); return SL_STATUS_NOT_SUPPORTED; } - std::vector set_data = { - {ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, - {ATTRIBUTE(USER_UNIQUE_ID), DESIRED_OR_REPORTED_ATTRIBUTE, user_unique_id_node} - }; + std::vector set_data + = {{ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, + {ATTRIBUTE(USER_UNIQUE_ID), + DESIRED_OR_REPORTED_ATTRIBUTE, + user_unique_id_node}}; // If we are not deleting the user we need more data if (user_operation_type != USER_SET_OPERATION_TYPE_DELETE) { @@ -1424,7 +2128,10 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( // Check if user still exists if (frame_data[INDEX_USER_MODIFIER_TYPE] == USER_REPORT_DNE) { - sl_log_debug(LOG_TAG, "User %d does not exist anymore, removing from attribute store.", user_id); + sl_log_debug( + LOG_TAG, + "User %d does not exist anymore, removing from attribute store.", + user_id); attribute_store_delete_node(user_unique_id_node); return SL_STATUS_OK; } @@ -1569,6 +2276,514 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, } } +///////////////////////////////////////////////////////////////////////////// +// Exposed class functions +///////////////////////////////////////////////////////////////////////////// + +sl_status_t zwave_command_class_user_credential_add_new_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) +{ + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); + return SL_STATUS_FAIL; + } + + // Check if the user already exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + // Node already exists, can't create user. + if (attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "User with ID %d already exists. Not adding user.", + user_id); + return SL_STATUS_FAIL; + } + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + // Create the user node + user_id_node = attribute_store_emplace_desired(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_TYPE), + &user_type, + sizeof(user_type)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE), + &credential_rule, + sizeof(credential_rule)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE), + &user_active_state, + sizeof(user_active_state)); + + if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + if (expiring_timeout != 0) { + sl_log_warning( + LOG_TAG, + "Expiring timeout set for non-expiring user, set value to 0."); + } + expiring_timeout = 0; + } + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + &user_name_encoding, + sizeof(user_name_encoding)); + // User name node + auto user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); + attribute_store_set_desired_string(user_name_node, user_name); + + // Finally set operation type add + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); + + sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + // Check if the user exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + // Node doesn't exists, can't delete user. + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d. Not deleting user.", + user_id); + return SL_STATUS_FAIL; + } + + // Finally set operation type delete + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_modify_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) +{ + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); + return SL_STATUS_FAIL; + } + + // Check if the user already exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + // Node already exists, can't create user. + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Can't modify user.", + user_id); + return SL_STATUS_FAIL; + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + std::map> values = { + {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, + {ATTRIBUTE(CREDENTIAL_RULE), {&credential_rule, sizeof(credential_rule)}}, + {ATTRIBUTE(USER_ACTIVE_STATE), + {&user_active_state, sizeof(user_active_state)}}, + {ATTRIBUTE(USER_NAME_ENCODING), + {&user_name_encoding, sizeof(user_name_encoding)}}, + {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, + }; + + // Only add expiring timeout if user is expiring + if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + {&expiring_timeout, sizeof(expiring_timeout)}}); + } + + // Update values based on the map + sl_status_t status = update_desired_values(user_id_node, values); + // If everything went well set operation type to modify + if (status == SL_STATUS_OK) { + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); + } else { + sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); + } + + return status; +} + +/** + * @brief Convert credential data str to a vector of uint8_t + * + * @note CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + * + * @param credential_data Credential data to convert + * @param credential_type Credential type + * @param credential_data_vector Vector to store the converted data + * + * @return SL_STATUS_OK if the conversion was successful, SL_STATUS_FAIL otherwise +*/ +sl_status_t get_credential_data(const char *credential_data, + user_credential_type_t credential_type, + std::vector &credential_data_vector) +{ + std::string credential_data_str(credential_data); + switch (credential_type) { + case CREDENTIAL_REPORT_PASSWORD: { + // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + try { + auto credential_data_utf16 = utf8_to_utf16(credential_data_str); + for (const auto &c: credential_data_utf16) { + credential_data_vector.push_back((uint8_t)(c >> 8)); + credential_data_vector.push_back((uint8_t)c); + } + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while converting credential data to UTF16: %s", + e.what()); + return SL_STATUS_FAIL; + } + } break; + case CREDENTIAL_REPORT_PIN_CODE: + for (const auto &c: credential_data_str) { + if (c < '0' || c > '9') { + sl_log_error(LOG_TAG, + "Invalid character in PIN code: %c. Only digits are " + "allowed.", + c); + return SL_STATUS_FAIL; + } + credential_data_vector.push_back(c); + } + break; + default: + for (const auto &c: credential_data_str) { + credential_data_vector.push_back(c); + } + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_add_new_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) +{ + // First see if the user exists + auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d. Not adding credentials.", + user_id); + return SL_STATUS_FAIL; + } + + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + // Create or update existing structure + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + // First check Credential Type existance + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + if (attribute_store_node_exists(credential_type_node)) { + get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); + + // If a Credential Slot already exists we can't add a new one + if (attribute_store_node_exists(credential_slot_node)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + } else { + // Create Credential Type if it doesn't exists + credential_type_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Create credential slot + credential_slot_node + = attribute_store_emplace_desired(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + // Process credential data + std::vector credential_data_vector; + sl_status_t credential_data_conversion_status + = get_credential_data(credential_data, + credential_type, + credential_data_vector); + // Something went wrong, we need to delete the slot + if (credential_data_conversion_status == SL_STATUS_FAIL) { + attribute_store_delete_node(credential_slot_node); + return SL_STATUS_FAIL; + } + + // Add data + uint8_t data_size = credential_data_vector.size(); + auto credential_data_length_node + = attribute_store_emplace_desired(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &data_size, + sizeof(data_size)); + + attribute_store_emplace_desired(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector.data(), + credential_data_vector.size()); + + // Finally set operation type add + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_modify_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) +{ + // Get credential structure + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + // First check Credential Type existence + bool node_found = get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + if (!node_found) { + sl_log_error( + LOG_TAG, + "Can't find Credential Type %d for User %d. Not modifing credentials.", + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + node_found = get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); + + if (!node_found) { + sl_log_error(LOG_TAG, + "Can't find Credential Slot %d for Credential Type %d (User " + "%d). Not modifing credentials.", + credential_slot, + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Process credential data + std::vector credential_data_vector; + sl_status_t credential_data_conversion_status + = get_credential_data(credential_data, + credential_type, + credential_data_vector); + // Something went wrong, we don't modify + if (credential_data_conversion_status == SL_STATUS_FAIL) { + sl_log_error(LOG_TAG, + "Something went wrong while processing credential data. Not " + "modifying credentials."); + return SL_STATUS_FAIL; + } + + // Add data + uint8_t data_size = credential_data_vector.size(); + + auto credential_data_length_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + + if (!attribute_store_node_exists(credential_data_length_node)) { + sl_log_error(LOG_TAG, + "Can't find CREDENTIAL_DATA_LENGTH in attribute store. Not " + "modifying credential."); + return SL_STATUS_FAIL; + } + attribute_store_set_desired(credential_data_length_node, + &data_size, + sizeof(data_size)); + + sl_status_t status + = attribute_store_set_child_desired(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector.data(), + credential_data_vector.size()); + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't set CREDENTIAL_DATA in attribute store. Not modifying " + "credential."); + return SL_STATUS_FAIL; + } + + // Finally set operation type modify + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + // First see if the user exists + auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d. Not adding credentials.", + user_id); + return SL_STATUS_FAIL; + } + + // Get credential structure + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + // First check Credential Type existence + bool node_found = get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + if (!node_found) { + sl_log_error( + LOG_TAG, + "Can't find Credential Type %d for User %d. Not deleting credentials.", + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + node_found = get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); + + if (!node_found) { + sl_log_error(LOG_TAG, + "Can't find Credential Slot %d for Credential Type %d (User " + "%d). Not deleting credentials.", + credential_slot, + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + // Finally set operation type delete + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + sl_log_debug(LOG_TAG, + "Delete credential slot %d (credential type %d, user id %d)", + credential_slot, + credential_type, + user_id); + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 9af030a3b..a2dc75450 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -25,11 +25,144 @@ #define ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_H #include "sl_status.h" +#include "zwave_command_class_user_credential_types.h" +#include "attribute_store.h" #ifdef __cplusplus extern "C" { #endif +/** + * @brief Send a new user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should NOT exists and NOT be 0 + * @param user_type The type of the user credential. + * @param credential_rule The rule associated with the user credential. + * @param user_active_state The active state of the user. + * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. + * @param user_name_encoding The encoding format of the user name. + * @param user_name The name of the user. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_add_new_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name); + + +/** + * @brief Send a modify user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Should NOT be 0. + * @param user_type The type of the user credential. + * @param credential_rule The rule associated with the user credential. + * @param user_active_state The active state of the user. + * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. + * @param user_name_encoding The encoding format of the user name. + * @param user_name The name of the user. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_modify_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name); + +/** + * @brief Send a delete user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists. +*/ +sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + +/** + * @brief Send a new credential command (Credential SET) to the end device + * + * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. + * - PINCode : Refuse any values that is not between '0' and '9'. + * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. + * - Others : Will be stored as is. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Can exist or not. Cannot be 0. + * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. + * @param credential_data Raw data of the credential. Checks are performed based on the credential type. + * + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential data is invalid. + */ +sl_status_t zwave_command_class_user_credential_add_new_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char* credential_data); + +/** + * @brief Send a modify credential command (Credential SET) to the end device + * + * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. + * - PINCode : Refuse any values that is not between '0' and '9'. + * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. + * - Others : Will be stored as is. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * @param credential_data Raw data of the credential. Checks are performed based on the credential type. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. Also if the credential data is invalid. + */ +sl_status_t zwave_command_class_user_credential_modify_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char* credential_data +); + +/** + * @brief Send a delete credential command (Credential SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. +*/ +sl_status_t zwave_command_class_user_credential_delete_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt index 71251b088..8fd7005d5 100644 --- a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt @@ -157,6 +157,9 @@ target_add_unittest( zwave_command_class_user_credential_test SOURCES zwave_command_class_user_credential_test.cpp + # Allow to use notification mock + EXCLUDE + zwave_command_class_notification.cpp DEPENDS zpc_attribute_store_test_helper zwave_controller @@ -164,7 +167,8 @@ target_add_unittest( uic_attribute_resolver_mock zpc_attribute_resolver_mock uic_dotdot_mqtt_mock - zwave_network_management_mock) + zwave_network_management_mock + zwave_command_class_notification_mock) # Wake Up Command Class target_add_unittest( @@ -873,6 +877,7 @@ target_add_unittest( zpc_attribute_resolver_mock uic_dotdot_mqtt_mock) + # CRC16 test target_add_unittest( zwave_command_classes diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index acb34f599..d7cb977ab 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -46,6 +46,7 @@ extern "C" { #include "zwave_command_handler_mock.h" #include "dotdot_mqtt_mock.h" #include "dotdot_mqtt_generated_commands_mock.h" +#include "zwave_command_class_notification_mock.h" // Used for delayed interview #include "zwave_network_management_mock.h" @@ -73,6 +74,9 @@ static std::map attributes_binding // e.g : resolver_functions[USER_CAPABILITIES_GET] = user_capabilities_get_func() static std::map resolver_functions; +// Notification callback +static notification_event_callback_t notification_callback; + // Buffer for frame static uint8_t received_frame[255] = {}; static uint16_t received_frame_size = 0; @@ -326,7 +330,7 @@ void helper_test_set_get_with_args( TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); } - for(auto &byte : extra_bytes) { + for (auto &byte: extra_bytes) { expected_frame.push_back(byte); } @@ -416,6 +420,14 @@ static sl_status_t return SL_STATUS_OK; } +static void zwave_command_class_notification_register_event_callback_stub( + attribute_store_node_t endpoint_node, + notification_event_callback_t callback, + int cmock_num_calls) +{ + notification_callback = callback; +} + static sl_status_t zwave_command_handler_register_handler_stub( zwave_command_handler_t new_command_class_handler, int cmock_num_calls) { @@ -460,6 +472,8 @@ void setUp() r.second = NULL; } + notification_callback = NULL; + memset(received_frame, 0, sizeof(received_frame)); received_frame_size = 0; // Unset previous definition of handler @@ -471,6 +485,9 @@ void setUp() // Handler registration zwave_command_handler_register_handler_Stub( &zwave_command_handler_register_handler_stub); + + zwave_command_class_notification_register_event_callback_Stub( + &zwave_command_class_notification_register_event_callback_stub); // Call init TEST_ASSERT_EQUAL(SL_STATUS_OK, zwave_command_class_user_credential_init()); } @@ -652,27 +669,18 @@ void test_user_credential_credential_capabilities_report_happy_case() std::vector cl_support = {1, 0, 0, 1}; std::vector supported_credential_slots = {1233, 11233, 21233, 33}; std::vector min_length = {2, 2362, 255, 1255}; - std::vector max_length = {5632, 15632, 25632, 32568}; + std::vector max_length = {5632, 15632, 25632, 32568}; + uint16_t expected_credential_type_mask = 0b11101; auto test_report_values = [&]() { - uint8_t reported_credential_checksum_support; - attribute_store_node_t support_node - = attribute_store_get_first_child_by_type( - endpoint_id_node, - ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM)); - - TEST_ASSERT_NOT_EQUAL_MESSAGE( - ATTRIBUTE_STORE_INVALID_NODE, - support_node, - "credential checksum support node should be defined"); - - attribute_store_get_reported(support_node, - &reported_credential_checksum_support, - sizeof(reported_credential_checksum_support)); + std::map uint8_attribute_map + = {{ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), credential_checksum_support}}; + std::map uint16_attribute_map + = {{DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, + expected_credential_type_mask}}; - TEST_ASSERT_EQUAL_MESSAGE(credential_checksum_support, - reported_credential_checksum_support, - "Incorrect reported credential checksum support"); + helper_test_attribute_store_values(uint8_attribute_map, endpoint_id_node); + helper_test_attribute_store_values(uint16_attribute_map, endpoint_id_node); for (uint8_t i = 0; i < credential_type.size(); i++) { printf("Testing credential batch %d\n", i); @@ -694,11 +702,10 @@ void test_user_credential_credential_capabilities_report_happy_case() reported_credential, "Incorrect credential type"); - std::map uint8_attribute_map = { + uint8_attribute_map = { {ATTRIBUTE(CREDENTIAL_LEARN_READ_BACK_SUPPORT), cl_support[i]}, }; - - std::map uint16_attribute_map = { + uint16_attribute_map = { {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), supported_credential_slots[i]}, {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), min_length[i]}, @@ -736,6 +743,8 @@ void test_user_credential_credential_capabilities_report_happy_case() supported_credential_slots, min_length, max_length); + expected_credential_type_mask = 0b11100000; + TEST_ASSERT_EQUAL( SL_STATUS_OK, handler.control_handler(&info, report_frame.data(), report_frame.size())); @@ -789,10 +798,10 @@ void test_user_credential_all_users_checksum_report_happy_case() //////////////////////////////////////////////////////////////////////////// void test_user_credential_user_set_add_or_modify_happy_case() { - user_credential_user_unique_id_t user_id = 12121; - user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_ADD; - user_credential_type_t user_type = 5; - user_credential_rule_t credential_rule = 2; + user_credential_user_unique_id_t user_id = 12121; + user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_ADD; + user_credential_type_t user_type = 5; + user_credential_rule_t credential_rule = 2; user_credential_user_active_state_t user_active_state = 1; user_credential_expiring_timeout_minutes_t expiring_timeout = 55; user_credential_user_name_encoding_t user_name_encoding = 0; @@ -840,18 +849,16 @@ void test_user_credential_user_set_add_or_modify_happy_case() TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, "Can't set username"); printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); - helper_test_set_get_with_args( - USER_SET, - operation_type_node, - {{operation_type_node, DESIRED_ATTRIBUTE}, - {user_id_node, REPORTED_ATTRIBUTE}, - {user_type_node, DESIRED_ATTRIBUTE}, - {user_active_state_node, REPORTED_ATTRIBUTE}, - {credential_rule_node, DESIRED_ATTRIBUTE}, - {expiring_timeout_node, REPORTED_ATTRIBUTE}, - {user_name_encoding_node, DESIRED_ATTRIBUTE}, - {user_name_node, REPORTED_ATTRIBUTE}}); - + helper_test_set_get_with_args(USER_SET, + operation_type_node, + {{operation_type_node, DESIRED_ATTRIBUTE}, + {user_id_node, REPORTED_ATTRIBUTE}, + {user_type_node, DESIRED_ATTRIBUTE}, + {user_active_state_node, REPORTED_ATTRIBUTE}, + {credential_rule_node, DESIRED_ATTRIBUTE}, + {expiring_timeout_node, REPORTED_ATTRIBUTE}, + {user_name_encoding_node, DESIRED_ATTRIBUTE}, + {user_name_node, REPORTED_ATTRIBUTE}}); printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); @@ -859,23 +866,23 @@ void test_user_credential_user_set_add_or_modify_happy_case() attribute_store_set_desired(operation_type_node, &operation_type, sizeof(operation_type)); - helper_test_set_get_with_args( - USER_SET, - operation_type_node, - {{operation_type_node, DESIRED_ATTRIBUTE}, - {user_id_node, REPORTED_ATTRIBUTE}, - {user_type_node, DESIRED_ATTRIBUTE}, - {user_active_state_node, REPORTED_ATTRIBUTE}, - {credential_rule_node, DESIRED_ATTRIBUTE}, - {expiring_timeout_node, REPORTED_ATTRIBUTE}, - {user_name_encoding_node, DESIRED_ATTRIBUTE}, - {user_name_node, REPORTED_ATTRIBUTE}}); + helper_test_set_get_with_args(USER_SET, + operation_type_node, + {{operation_type_node, DESIRED_ATTRIBUTE}, + {user_id_node, REPORTED_ATTRIBUTE}, + {user_type_node, DESIRED_ATTRIBUTE}, + {user_active_state_node, REPORTED_ATTRIBUTE}, + {credential_rule_node, DESIRED_ATTRIBUTE}, + {expiring_timeout_node, REPORTED_ATTRIBUTE}, + {user_name_encoding_node, DESIRED_ATTRIBUTE}, + {user_name_node, REPORTED_ATTRIBUTE}}); } void test_user_credential_user_delete_remove_happy_case() { - user_credential_user_unique_id_t user_id = 12121; - user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_DELETE; + user_credential_user_unique_id_t user_id = 12121; + user_credential_operation_type_t operation_type + = USER_SET_OPERATION_TYPE_DELETE; auto user_id_node = attribute_store_emplace(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), @@ -899,7 +906,6 @@ void test_user_credential_user_set_invalid_node() helper_test_set_get_with_args(USER_SET, ATTRIBUTE_STORE_INVALID_NODE); } - void test_user_credential_user_get_happy_case() { user_credential_user_unique_id_t user_id = 12; @@ -963,6 +969,80 @@ std::vector helper_create_user_report_frame( return report_frame; }; +std::vector helper_create_user_notification_report( + user_credential_user_modifier_type_t user_modifier_type, + user_credential_user_modifier_node_id_t user_modifier_node_id, + user_credential_user_unique_id_t user_id, + user_credential_user_type_t user_type, + user_credential_user_active_state_t user_active_state, + user_credential_supported_credential_rules_t credential_rule, + user_credential_expiring_timeout_minutes_t expiring_timeout_minutes) +{ + // FIXME: This will be changed + // https://github.com/Z-Wave-Alliance/z-wave-stack/issues/409 + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, USER_NOTIFICATION_REPORT}; + + report_frame.push_back(user_modifier_type); + + auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); + report_frame.push_back(exploded_user_modifier_node_id.msb); + report_frame.push_back(exploded_user_modifier_node_id.lsb); + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(user_type); + report_frame.push_back(user_active_state); + report_frame.push_back(credential_rule); + + auto exploded_time = explode_uint16(expiring_timeout_minutes); + report_frame.push_back(exploded_time.msb); + report_frame.push_back(exploded_time.lsb); + + return report_frame; +}; + +// FIXME: Will be changed +// https://github.com/Z-Wave-Alliance/AWG/issues/168 +std::vector helper_create_credential_notification_report( + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + bool crb, + const std::string &credential_data, + user_credential_modifier_type_t modifier_type, + user_credential_modifier_node_id_t modifier_node_id) +{ + std::vector report_frame; + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(credential_type); + + auto exploded_credential_slot = explode_uint16(credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(crb ? 1 : 0); + report_frame.push_back(credential_data.size()); + + for (auto &c: credential_data) { + report_frame.push_back(c); + } + + report_frame.push_back(modifier_type); + + auto exploded_modifier_node_id = explode_uint16(modifier_node_id); + report_frame.push_back(exploded_modifier_node_id.msb); + report_frame.push_back(exploded_modifier_node_id.lsb); + + return report_frame; +}; + void test_user_credential_user_report_happy_case() { zwave_controller_connection_info_t info = {}; @@ -1287,10 +1367,11 @@ void test_user_credential_user_report_user_deleted() //>> Set void test_user_credential_credential_set_1byte_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_ADD; - std::vector credential_data = {12}; + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type + = USER_CREDENTIAL_OPERATION_TYPE_ADD; + std::vector credential_data = {12}; // Create the node with reported attribute auto nodes = helper_create_credential_structure(12, @@ -1304,9 +1385,9 @@ void test_user_credential_credential_set_1byte_happy_case() // Operation type auto operation_type_node = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); // CREDENTIAL_DATA uint8_t credential_data_length = credential_data.size(); auto credential_data_length_node @@ -1334,9 +1415,10 @@ void test_user_credential_credential_set_1byte_happy_case() void test_user_credential_credential_set_12byte_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_MODIFY; + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type + = USER_CREDENTIAL_OPERATION_TYPE_MODIFY; std::vector credential_data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; @@ -1352,9 +1434,9 @@ void test_user_credential_credential_set_12byte_happy_case() // Operation type auto operation_type_node = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); // CREDENTIAL_DATA uint8_t credential_data_length = credential_data.size(); auto credential_data_length_node @@ -1387,9 +1469,10 @@ void test_user_credential_credential_set_invalid_node() void test_user_credential_credential_set_delete_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type = USER_CREDENTIAL_OPERATION_TYPE_DELETE; + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; + user_credential_operation_type_t operation_type + = USER_CREDENTIAL_OPERATION_TYPE_DELETE; // Create the node with reported attribute auto nodes = helper_create_credential_structure(12, @@ -1403,9 +1486,9 @@ void test_user_credential_credential_set_delete_happy_case() // Operation type auto operation_type_node = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &operation_type, + sizeof(operation_type)); helper_test_set_get_with_args(CREDENTIAL_SET, operation_type_node, @@ -1415,11 +1498,10 @@ void test_user_credential_credential_set_delete_happy_case() {credential_slot_node, REPORTED_ATTRIBUTE}, {operation_type_node, DESIRED_ATTRIBUTE}, }, - {0x00} // Credential data length - ); + {0x00} // Credential data length + ); } - //>> Get void test_user_credential_credential_get_happy_case() @@ -2024,4 +2106,331 @@ void test_post_interview_discovery() count_user_node(1); } +void test_user_credential_notification_empty_parameters() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + std::vector empty_event_parameters = {}; + // Test all available notification types + // No error should occurs even if parameters are not well defined + std::vector notification_access_control_event_types = {0x23, + 0x24, + 0x25, + 0x26, + 0x27, + 0x28, + 0x29, + 0x2A, + 0x2B, + 0x2C, + 0x2D, + 0x2E, + 0x2F, + 0x30, + 0x31, + 0x32, + 0x33}; + for (auto event_type: notification_access_control_event_types) { + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + event_type, + empty_event_parameters.data(), + empty_event_parameters.size()); + } +} + +void test_user_credential_user_notification_add_modify_delete_happy_case() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + // Setup user + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t user_type = 2; + user_credential_rule_t credential_rule = 1; + user_credential_user_active_state_t user_active_state = 1; + user_credential_expiring_timeout_minutes_t expiring_timeout = 0; + user_credential_user_name_encoding_t user_name_encoding = 0; + std::string user_name = "MICHEL VNR"; + + // Add user + sl_status_t status + = zwave_command_class_user_credential_add_new_user(endpoint_id_node, + user_id, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "User add should have returned SL_STATUS_OK"); + // Get user node + auto user_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_node), + "An user node should exist"); + + // Create notification report frame + user_credential_user_modifier_type_t user_modifier_type = 2; + user_credential_user_modifier_node_id_t user_modifier_node_id = 1212; + + auto user_notification_report_frame + = helper_create_user_notification_report(user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout); + + // Endpoint send User Add notification + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x27, // User added + user_notification_report_frame.data(), + user_notification_report_frame.size()); + + // Check values + auto test_attribute_store_values = [&]() { + std::map uint8_attribute_map + = {{ATTRIBUTE(USER_MODIFIER_TYPE), user_modifier_type}, + {ATTRIBUTE(USER_TYPE), user_type}, + {ATTRIBUTE(USER_ACTIVE_STATE), user_active_state}, + {ATTRIBUTE(CREDENTIAL_RULE), credential_rule}}; + helper_test_attribute_store_values(uint8_attribute_map, user_node); + + std::map uint16_attribute_map + = {{ATTRIBUTE(USER_MODIFIER_NODE_ID), user_modifier_node_id}, + {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), expiring_timeout}}; + helper_test_attribute_store_values(uint16_attribute_map, user_node); + + helper_test_string_value({{ATTRIBUTE(USER_NAME), user_name}}, user_node); + }; + test_attribute_store_values(); + + // Now let's modify this user + user_type = 7; + credential_rule = 2; + user_active_state = 0; + expiring_timeout = 10; + user_name_encoding = 2; + user_name = "JACKIE CAMION TURBO PLUS"; + + status = zwave_command_class_user_credential_modify_user(endpoint_id_node, + user_id, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "User modify should have returned SL_STATUS_OK"); + + // Create notification report frame + user_modifier_type = 5; + user_modifier_node_id = 12122; + + user_notification_report_frame + = helper_create_user_notification_report(user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout); + + // Endpoint send User Modify notification + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x28, // User modified + user_notification_report_frame.data(), + user_notification_report_frame.size()); + + // Check values + test_attribute_store_values(); + + // Now let's delete this user + status = zwave_command_class_user_credential_delete_user(endpoint_id_node, + user_id); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "User delete should have returned SL_STATUS_OK"); + + // Should be the same as existing user + user_notification_report_frame + = helper_create_user_notification_report(user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout); + + // Endpoint send User Modify notification + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x29, // User deleted + user_notification_report_frame.data(), + user_notification_report_frame.size()); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_node), + "User node should be deleted"); +} + +void test_user_credential_credential_notification_add_modify_delete_happy_case() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + bool crb = true; + std::string credential_data = "12"; + user_credential_modifier_type_t credential_modifier_type = 2; + user_credential_modifier_node_id_t credential_modifier_node_id = 1212; + + // Simulate user + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Add credential + sl_status_t status = zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + credential_data.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Credential add should have returned SL_STATUS_OK"); + + // Get credential type + auto credential_type_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should exist"); + + // Get credential slot + auto credential_slot_node + = attribute_store_get_first_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential slot node should exist"); + + // Create notification report frame + auto credential_notification_report + = helper_create_credential_notification_report(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id); + + // Endpoint send User Add notification + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x2B, // Credential added + credential_notification_report.data(), + credential_notification_report.size()); + + // Check values + auto test_attribute_store_values = [&]() { + std::map uint8_attribute_map + = {{ATTRIBUTE(CREDENTIAL_TYPE), credential_type}}; + helper_test_attribute_store_values(uint8_attribute_map, user_id_node); + + std::map uint16_attribute_map + = {{ATTRIBUTE(CREDENTIAL_SLOT), credential_slot}}; + helper_test_attribute_store_values(uint16_attribute_map, + credential_type_node); + + uint8_attribute_map + = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}, + {ATTRIBUTE(CREDENTIAL_DATA_LENGTH), credential_data.size()}}; + helper_test_attribute_store_values(uint8_attribute_map, + credential_slot_node); + + uint16_attribute_map + = {{ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), credential_modifier_node_id}}; + helper_test_attribute_store_values(uint16_attribute_map, + credential_slot_node); + }; + test_attribute_store_values(); + + crb = false; + ; + credential_data = "121212"; + credential_modifier_type = 3; + credential_modifier_node_id = 15; + + // Modify credential + credential_notification_report + = helper_create_credential_notification_report(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id); + + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x2C, // Credential modified + credential_notification_report.data(), + credential_notification_report.size()); + + test_attribute_store_values(); + + // Delete credential + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x2D, // Credential deleted + credential_notification_report.data(), + credential_notification_report.size()); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential slot node should be deleted"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + "User ID node should still exist"); +} + } // extern "C" \ No newline at end of file From fca613aaeef8f431722d609dd64e2b10f56b6a86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 18 Apr 2024 16:38:07 +0200 Subject: [PATCH 06/60] UIC-3222: Refactor modifier_type_t and modifier_node_id --- .../user_credential_cluster_server_test.cpp | 4 ++-- ...wave_command_class_user_credential_types.h | 11 ++++----- .../zwave_command_class_user_credential.cpp | 4 ++-- ...ave_command_class_user_credential_test.cpp | 24 +++++++++---------- 4 files changed, 20 insertions(+), 23 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 5111e316b..4f004618a 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -533,8 +533,8 @@ attribute_store_node_t helper_add_complete_user( // Reported attributes by the end device // Need those to test MQTT topics - user_credential_user_modifier_node_id_t modifier_node_id = 1212; - user_credential_user_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_LOCALLY; + user_credential_modifier_node_id_t modifier_node_id = 1212; + user_credential_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_LOCALLY; mock_expected_user_mqtt_topic(user_id, "UserModifierNodeId", static_cast(modifier_node_id)); diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index fd3df4577..8ec3d4e2f 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -36,9 +36,11 @@ typedef uint16_t user_credential_all_users_checksum_t; ///> User Unique ID. uint16_t typedef uint16_t user_credential_user_unique_id_t; ///> User Modifier Type. uint8_t -typedef uint8_t user_credential_user_modifier_type_t; +typedef uint8_t user_credential_modifier_type_t; ///> User Modifier Node ID. uint16_t -typedef uint16_t user_credential_user_modifier_node_id_t; +typedef uint16_t user_credential_modifier_node_id_t; + + ///> User Type. uint8_t #define USER_CREDENTIAL_USER_TYPE_GENERAL_USER 0x00 #define USER_CREDENTIAL_USER_TYPE_PROGRAMMING_USER 0x03 @@ -68,11 +70,6 @@ typedef uint16_t user_credential_slot_t; #define USER_CREDENTIAL_OPERATION_TYPE_DELETE 0x02 typedef uint8_t user_credential_operation_type_t; -///> Credential Modifier Type. uint8_t -typedef uint8_t user_credential_modifier_type_t; -///> Credential Modifier Node ID. uint16_t -typedef uint16_t user_credential_modifier_node_id_t; - ///> Expiring Timeout for User (Minutes). uint16_t typedef uint16_t user_credential_expiring_timeout_minutes_t; diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 02ea0ecfa..5f45d2923 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -623,7 +623,7 @@ user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); } -user_credential_user_modifier_type_t +user_credential_modifier_type_t get_user_modifier_type(const uint8_t *event_parameters) { return event_parameters[INDEX_USER_MODIFIER_TYPE]; @@ -910,7 +910,7 @@ void on_notification_event(attribute_store_node_t endpoint_node, } // If user doesn't exists in the device we try to remove it also from our side - user_credential_user_modifier_type_t modifier_type + user_credential_modifier_type_t modifier_type = notification_handler::user::get_user_modifier_type(event_parameters); if (modifier_type == USER_REPORT_DNE) { attribute_store_delete_node(user_id_node); diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index d7cb977ab..003c17a30 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -926,8 +926,8 @@ void test_user_credential_user_get_not_found() std::vector helper_create_user_report_frame( user_credential_user_unique_id_t next_user_id, - user_credential_user_modifier_type_t user_modifier_type, - user_credential_user_modifier_node_id_t user_modifier_node_id, + user_credential_modifier_type_t user_modifier_type, + user_credential_modifier_node_id_t user_modifier_node_id, user_credential_user_unique_id_t user_id, user_credential_user_type_t user_type, user_credential_user_active_state_t user_active_state, @@ -970,8 +970,8 @@ std::vector helper_create_user_report_frame( }; std::vector helper_create_user_notification_report( - user_credential_user_modifier_type_t user_modifier_type, - user_credential_user_modifier_node_id_t user_modifier_node_id, + user_credential_modifier_type_t user_modifier_type, + user_credential_modifier_node_id_t user_modifier_node_id, user_credential_user_unique_id_t user_id, user_credential_user_type_t user_type, user_credential_user_active_state_t user_active_state, @@ -1057,8 +1057,8 @@ void test_user_credential_user_report_happy_case() constexpr user_credential_user_unique_id_t EXPECTED_SECOND_USER_ID = 1212; user_credential_user_unique_id_t next_user_id = EXPECTED_SECOND_USER_ID; - user_credential_user_modifier_type_t user_modifier_type = 2; - user_credential_user_modifier_node_id_t user_modifier_node_id = 1313; + user_credential_modifier_type_t user_modifier_type = 2; + user_credential_modifier_node_id_t user_modifier_node_id = 1313; user_credential_user_unique_id_t user_id = EXPECTED_FIRST_USER_ID; user_credential_user_type_t user_type = 3; user_credential_user_active_state_t user_active_state = 1; @@ -1536,8 +1536,8 @@ std::vector helper_create_credential_report_frame( user_credential_slot_t credential_slot, uint8_t crb, std::vector credential_data, - user_credential_user_modifier_type_t credential_modifier_type, - user_credential_user_modifier_node_id_t credential_modifier_node_id, + user_credential_modifier_type_t credential_modifier_type, + user_credential_modifier_node_id_t credential_modifier_node_id, user_credential_type_t next_credential_type, user_credential_slot_t next_credential_slot) { @@ -1703,8 +1703,8 @@ void test_user_credential_credential_report_happy_case() user_credential_slot_t credential_slot = 1212; uint8_t crb = 1; std::vector credential_data = {12, 13, 14, 15, 16}; - user_credential_user_modifier_type_t credential_modifier_type = 13; - user_credential_user_modifier_node_id_t credential_modifier_node_id = 1312; + user_credential_modifier_type_t credential_modifier_type = 13; + user_credential_modifier_node_id_t credential_modifier_node_id = 1312; user_credential_type_t next_credential_type = 12; user_credential_slot_t next_credential_slot = 1; @@ -2190,8 +2190,8 @@ void test_user_credential_user_notification_add_modify_delete_happy_case() "An user node should exist"); // Create notification report frame - user_credential_user_modifier_type_t user_modifier_type = 2; - user_credential_user_modifier_node_id_t user_modifier_node_id = 1212; + user_credential_modifier_type_t user_modifier_type = 2; + user_credential_modifier_node_id_t user_modifier_node_id = 1212; auto user_notification_report_frame = helper_create_user_notification_report(user_modifier_type, From 8ff3ca616a3d362eca142f23199fd125e13a35c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 22 May 2024 14:12:36 +0200 Subject: [PATCH 07/60] UIC-3222: Enforce Credential and User Capabilities UIC-3222: Credential capabilities update --- .../user_credential_cluster_server_test.cpp | 75 +- .../zwave_command_class_user_credential.cpp | 382 ++++++++- ...ave_command_class_user_credential_test.cpp | 769 +++++++++++++++--- 3 files changed, 1102 insertions(+), 124 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 4f004618a..35438461f 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -51,6 +51,10 @@ void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id); void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot); +void mock_deletion_cred_rule_mqtt_topic(user_credential_type_t credential_type); +void setup_user_capabilities(); +void setup_cred_capabilities(); + // Keep a reference to the mqtt topics we want to test // Stored as @@ -60,6 +64,8 @@ static std::vector> created_credential_ids; +static std::vector + created_supported_credential_types; // Callback functions // clang-format off @@ -132,6 +138,11 @@ int suiteTearDown(int num_failures) /// Called before each and every test void setUp() { + // WARNING : Order matters here + // Check if credential rules need to be removed + for(auto cred_type: created_supported_credential_types) { + mock_deletion_cred_rule_mqtt_topic(cred_type); + } // Check if any users that need to be removed for (auto user_id: created_user_id) { // Check if MQTT topics for deletion are correctly published @@ -143,6 +154,8 @@ void setUp() std::get<2>(cred_id)); } + + zpc_attribute_store_test_helper_create_network(); // Intercept the dotdot MQTT callbacks @@ -154,7 +167,7 @@ void setUp() mqtt_topics.clear(); created_user_id.clear(); created_credential_ids.clear(); - + created_supported_credential_types.clear(); // clang-format off // User uic_mqtt_dotdot_user_credential_add_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_add_user_callback_set_stub); @@ -168,20 +181,29 @@ void setUp() // Run the component init TEST_ASSERT_EQUAL(SL_STATUS_OK, user_credential_cluster_server_init()); + + // We are not here to test user capabilities, so we need to set them up to + // accept our test data + setup_user_capabilities(); + // Need to call this after init() to have the mqtt callback initialized + setup_cred_capabilities(); } ///////////////////////////////////////////////////////////////////////// // Mqtt topics helpers ///////////////////////////////////////////////////////////////////////// -std::string get_base_topic() +std::string get_base_topic(bool include_user=true) { + const std::string user_str = include_user ? "/User" : ""; const std::string base - = "ucl/by-unid/%1%/ep%2%/UserCredential/Attributes/User"; + = "ucl/by-unid/%1%/ep%2%/UserCredential/Attributes%3%"; return (boost::format(base) % supporting_node_unid - % (unsigned int)endpoint_id) + % (unsigned int)endpoint_id % user_str) .str(); } + + std::string get_user_attribute_mqtt_topic(user_credential_user_unique_id_t user_unique_id, const std::string &attribute_name) @@ -205,6 +227,17 @@ std::string .str(); } +std::string + get_cred_rule_mqtt_topic(user_credential_type_t credential_type, + const std::string &attribute_name) +{ + const std::string base = "%1%/Credentials/%2%/%3%/Reported"; + return (boost::format(base) % get_base_topic(false) + % cred_type_get_enum_value_name(credential_type) + % attribute_name) + .str(); +} + } // extern "C" template std::string get_payload(T value) @@ -250,7 +283,21 @@ void mock_expected_cred_mqtt_topic(user_credential_user_unique_id_t user_id, mqtt_topics.back().second.size(), true); } +template +void mock_expected_cred_rule_mqtt_topic(user_credential_type_t credential_type, + const std::string &attribute_name, + T payload_value) +{ + // This way we make sure that we have valid reference to our strings + mqtt_topics.push_back( + {get_cred_rule_mqtt_topic(credential_type, attribute_name), + get_payload(payload_value)}); + uic_mqtt_publish_Expect(mqtt_topics.back().first.c_str(), + mqtt_topics.back().second.c_str(), + mqtt_topics.back().second.size(), + true); +} void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id) { // WARNING : Order here matters based on their initialization order in the add_complete_user function @@ -1244,7 +1291,7 @@ void test_user_credential_cluster_add_credential_others_happy_case() { // Simulate user user_credential_user_unique_id_t user_unique_id = 12; - CredType credential_type = CredType::ZCL_CRED_TYPE_NFC; + CredType credential_type = CredType::ZCL_CRED_TYPE_RFID_CODE; user_credential_slot_t credential_slot = 1; const char *credential_data = "hunter2"; @@ -1546,13 +1593,6 @@ void test_user_credential_cluster_delete_credential_happy_case() void test_user_credential_cluster_test_user_command_support_happy_case() { - // Emplace checked attributes - uint16_t user_count = 2; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(NUMBER_OF_USERS), - &user_count, - sizeof(user_count)); - // We don't care about those value it should not matter here user_credential_user_unique_id_t user_unique_id = 12; UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_DISPOSABLE_USER; @@ -1610,6 +1650,15 @@ void test_user_credential_cluster_test_user_command_not_supported_happy_case() UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; const char *user_name = "Test User"; + // We don't want anything in the tree for this test + // This way we can make support check fails + // We need to inform the MQTT of the deleted credential type rules + for(auto cred_type: created_supported_credential_types) { + mock_deletion_cred_rule_mqtt_topic(cred_type); + } + // Delete all the nodes + attribute_store_delete_all_children(endpoint_id_node); + TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, add_user_command(supporting_node_unid, @@ -1622,7 +1671,7 @@ void test_user_credential_cluster_test_user_command_not_supported_happy_case() user_name, expiring_timeout, user_name_encoding), - "Add user should not be supported"); + "Check value : Add user should not be supported"); TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 5f45d2923..adf95131d 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -95,6 +95,306 @@ struct attribute_command_data { attribute_store_node_t node = ATTRIBUTE_STORE_INVALID_NODE; }; +///////////////////////////////////////////////////////////////////////////// +// Capabilites Data Structs +///////////////////////////////////////////////////////////////////////////// +// User capabilities +struct user_capabilities { + // Maximum number of users that can be stored in the device + uint16_t max_user_count = 0; + // Credential rules supported + uint8_t supported_credential_rules_bitmask = 0; + // User types supported + uint32_t supported_user_types_bitmask = 0; + // Max length for the user names + uint8_t max_user_name_length = 0; + // Device support for scheduling users + uint8_t support_user_schedule = 0; + // Device support for getting the checksum of all users + uint8_t support_all_user_checksum = 0; + // Device support for getting the checksum of a specific user + uint8_t support_by_user_checksum = 0 ; + + // True if the data is valid inside this struct + bool is_data_valid = false; + + /** + * @brief Check if the user proprieties are valid + * + * @note Will return false if is_data_valid is false + * + * @param user_id User ID + * @param user_type User type + * @param credential_rule Credential rule + * @param user_name User name + * + * @return true User is valid + * @return false User is not valid + */ + bool is_user_valid(user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + const char *user_name) + { + if (!is_data_valid) { + sl_log_error( + LOG_TAG, + "User capabilities are not valid. Try restarting the device."); + return false; + } + + if (!is_user_id_valid(user_id)) { + sl_log_error(LOG_TAG, "User ID is not valid."); + return false; + } + + if (!is_user_type_supported(user_type)) { + sl_log_error(LOG_TAG, "User type is not supported."); + return false; + } + + if (!is_credential_rule_supported(credential_rule)) { + sl_log_error(LOG_TAG, "Credential rule is not supported."); + return false; + } + + if (!is_user_name_valid(user_name)) { + sl_log_error(LOG_TAG, "User name is not valid."); + return false; + } + return true; + } + + /** + * @brief Checks if the given user name is valid. + * @param user_name The user name to be validated. + * @return true User name is valid + * @return false User name is not valid + */ + bool is_user_name_valid(const char* user_name) const + { + std::string str_user_name(user_name); + return str_user_name.length() <= max_user_name_length; + } + + /** + * @brief Check if a user id is valid + * @param user_id User ID to check + * @return true User ID is valid + * @return false User ID is not valid + */ + bool is_user_id_valid(user_credential_user_unique_id_t user_id) + { + return user_id <= max_user_count; + } + /** + * @brief Check if a user type is supported + * @param user_type User type to check + * @return true User type is supported + * @return false User type is not supported + */ + bool is_user_type_supported(user_credential_type_t user_type) const + { + return (supported_user_types_bitmask & (1 << user_type)); + } + + /** + * @brief Check if a credential rule is supported + * @param credential_rule Credential rule to check + * @return true Credential rule is supported + * @return false Credential rule is not supported + */ + bool is_credential_rule_supported(user_credential_rule_t credential_rule) const + { + return (supported_credential_rules_bitmask & (1 << credential_rule)); + } +}; + + +// Associated with a Credential type +struct credential_capabilities { + user_credential_type_t credential_type = 0; + uint16_t max_slot_count = 0; + uint8_t learn_support = 0; + uint16_t min_credential_length = 0; + uint16_t max_credential_length = 0; + uint8_t learn_recommended_timeout = 0; + uint8_t learn_number_of_steps = 0; + + bool is_data_valid = false; + + bool is_credential_valid(user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::vector &credential_data) + { + + if (!is_data_valid) { + sl_log_error( + LOG_TAG, + "Credential capabilities are not valid. Try restarting the device."); + return false; + } + + if (credential_type != this->credential_type) { + sl_log_error(LOG_TAG, "Credential type mismatch."); + return false; + } + + if (!is_slot_valid(credential_slot)) { + sl_log_error( + LOG_TAG, + "Slot ID is not valid. Given : %d, Max Supported Slot count : %d", + credential_slot, + max_slot_count); + return false; + } + + if (!is_credential_data_valid(credential_data)) { + sl_log_error(LOG_TAG, "Credential data size is not valid. Should be between %d and %d, given : %d", + min_credential_length, + max_credential_length, + credential_data.size()); + return false; + } + + return true; + } + + bool is_slot_valid(user_credential_slot_t credential_slot) const + { + return credential_slot <= max_slot_count; + } + + bool is_credential_data_valid(const std::vector &credential_data) const + { + return (credential_data.size() >= min_credential_length + && credential_data.size() <= max_credential_length); + } +}; + +///////////////////////////////////////////////////////////////////////////// +// Capabilites Helpers +///////////////////////////////////////////////////////////////////////////// +/** + * @brief Get the attributes of a node + * + * @param parent_node Parent node of the attributes + * @param attributes Fill the attribute_store_type_t with the corresponding value inside the pointer + * + * @return sl_status_t SL_STATUS_OK if everything was fine ; otherwise an error code +*/ +sl_status_t get_attributes(attribute_store_node_t parent_node, + std::map attributes) +{ + sl_status_t status = SL_STATUS_OK; + for (auto &attribute: attributes) { + size_t attribute_size = 0; + switch (attribute_store_get_storage_type(attribute.first)) { + case U8_STORAGE_TYPE: + attribute_size = sizeof(uint8_t); + break; + case U16_STORAGE_TYPE: + attribute_size = sizeof(uint16_t); + break; + case U32_STORAGE_TYPE: + attribute_size = sizeof(uint32_t); + break; + default: + sl_log_error( + LOG_TAG, + "Unsupported storage type for attribute %d. Can't get capabilities.", + attribute.first); + return SL_STATUS_FAIL; + } + + sl_status_t current_status + = attribute_store_get_child_reported(parent_node, + attribute.first, + attribute.second, + attribute_size); + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get value for attribute %s", + attribute_store_get_type_name(attribute.first)); + } + + status |= current_status; + } + return status; +} + +/** + * @brief Get the user capabilities of a node + * + * @param endpoint_node Endpoint node + * + * @return user_capabilities User capabilities. is_data_valid will be false if an error occurred +*/ +user_capabilities get_user_capabilities(attribute_store_node_t endpoint_node) +{ + user_capabilities capabilities; + + std::map attributes = { + {ATTRIBUTE(NUMBER_OF_USERS), &capabilities.max_user_count}, + {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), &capabilities.supported_credential_rules_bitmask}, + {ATTRIBUTE(SUPPORTED_USER_TYPES), &capabilities.supported_user_types_bitmask}, + {ATTRIBUTE(MAX_USERNAME_LENGTH), &capabilities.max_user_name_length}, + {ATTRIBUTE(SUPPORT_USER_SCHEDULE), &capabilities.support_user_schedule}, + {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), &capabilities.support_all_user_checksum}, + {ATTRIBUTE(SUPPORT_USER_CHECKSUM), &capabilities.support_by_user_checksum} + }; + + sl_status_t status = get_attributes(endpoint_node, attributes); + + capabilities.is_data_valid = (status == SL_STATUS_OK); + + return capabilities; +} + +/** + * @brief Get the credential capabilities of a node for given credential type + * + * @param endpoint_node Endpoint node + * @param credential_type Credential type + * + * @return credential_capabilities Credential capabilities. is_data_valid will be false if an error occurred +*/ +credential_capabilities + get_credential_capabilities(attribute_store_node_t endpoint_node, + user_credential_type_t credential_type) +{ + credential_capabilities capabilities; + + attribute_store_node_t supported_credential_type_node + = attribute_store_get_node_child_by_value( + endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + + if (!attribute_store_node_exists(supported_credential_type_node)) { + sl_log_error(LOG_TAG, "Credential type %d not supported. Can't get capabilities", credential_type); + return capabilities; + } + + std::map attributes = { + {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), &capabilities.max_slot_count}, + {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), &capabilities.learn_support}, + {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), &capabilities.min_credential_length}, + {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), &capabilities.max_credential_length}, + {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), &capabilities.learn_recommended_timeout}, + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), &capabilities.learn_number_of_steps} + }; + + sl_status_t status = get_attributes(supported_credential_type_node, attributes); + capabilities.credential_type = credential_type; + capabilities.is_data_valid = (status == SL_STATUS_OK); + + return capabilities; +} + ///////////////////////////////////////////////////////////////////////////// // Type Helpers ///////////////////////////////////////////////////////////////////////////// @@ -1396,7 +1696,7 @@ sl_status_t attribute_store_set_child_reported( credential_type_node, - ATTRIBUTE(CREDENTIAL_LEARN_READ_BACK_SUPPORT), + ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), &support_cl, sizeof(support_cl)); @@ -1422,6 +1722,28 @@ sl_status_t store_uint16_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH), 1); store_uint16_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH), 2); + // End for Credential Max Length values + const uint8_t offset = 3; + const uint16_t cl_recommended_index + = cl_support_index + supported_credential_types_count + + (supported_credential_types_count * 2 * offset); + + uint8_t recommended_timeout = frame_data[cl_recommended_index]; + attribute_store_set_child_reported( + credential_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + &recommended_timeout, + sizeof(recommended_timeout)); + + // Offset of supported_credential_types_count for next 8 bit value + const uint16_t cl_number_of_steps_index + = cl_recommended_index + supported_credential_types_count; + uint8_t cl_number_of_steps = frame_data[cl_number_of_steps_index]; + attribute_store_set_child_reported( + credential_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), + &cl_number_of_steps, + sizeof(cl_number_of_steps)); current_index++; } @@ -2319,6 +2641,13 @@ sl_status_t zwave_command_class_user_credential_add_new_user( sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + // Check capabilites + user_capabilities capabilites = get_user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, user_type, credential_rule, user_name)) { + sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } + // Create the user node user_id_node = attribute_store_emplace_desired(endpoint_node, ATTRIBUTE(USER_UNIQUE_ID), @@ -2435,6 +2764,13 @@ sl_status_t zwave_command_class_user_credential_modify_user( sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + // Check capabilites + user_capabilities capabilites = get_user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, user_type, credential_rule, user_name)) { + sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } + std::map> values = { {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, {ATTRIBUTE(CREDENTIAL_RULE), {&credential_rule, sizeof(credential_rule)}}, @@ -2557,7 +2893,7 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( REPORTED_ATTRIBUTE, credential_slot_node); - // If a Credential Slot already exists we can't add a new one + // If a Credential Slot already exists we can't add a ne w one if (attribute_store_node_exists(credential_slot_node)) { sl_log_error(LOG_TAG, "Credential slot %d for Credential Type %d already exists. " @@ -2585,13 +2921,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - // Create credential slot - credential_slot_node - = attribute_store_emplace_desired(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - // Process credential data std::vector credential_data_vector; sl_status_t credential_data_conversion_status @@ -2600,10 +2929,31 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( credential_data_vector); // Something went wrong, we need to delete the slot if (credential_data_conversion_status == SL_STATUS_FAIL) { - attribute_store_delete_node(credential_slot_node); return SL_STATUS_FAIL; } + + auto capabilities + = get_credential_capabilities(endpoint_node, credential_type); + + if (!capabilities.is_credential_valid(credential_type, + credential_slot, + credential_data_vector)) { + sl_log_error( + LOG_TAG, + "Credential capabilities are not valid. Not adding credential."); + return SL_STATUS_FAIL; + } + + // Create credential slot + credential_slot_node + = attribute_store_emplace_desired(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + + // Add data uint8_t data_size = credential_data_vector.size(); auto credential_data_length_node @@ -2688,6 +3038,18 @@ sl_status_t zwave_command_class_user_credential_modify_credential( return SL_STATUS_FAIL; } + // Verify credential validity + auto capabilities + = get_credential_capabilities(endpoint_node, credential_type); + if (!capabilities.is_credential_valid(credential_type, + credential_slot, + credential_data_vector)) { + sl_log_error( + LOG_TAG, + "Credential capabilities are not valid. Not adding credential."); + return SL_STATUS_FAIL; + } + // Add data uint8_t data_size = credential_data_vector.size(); diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 003c17a30..4f26f7851 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -137,6 +137,114 @@ struct credential_structure_nodes { attribute_store_node_t credential_slot_node; }; +void helper_simulate_user_capabilites_report( + uint16_t number_of_users, + user_credential_supported_credential_rules_t cred_rule_bitmask, + uint8_t username_max_length, + uint8_t support_user_schedule, + uint8_t support_all_users_checksum, + uint8_t support_user_checksum, + uint8_t supported_user_types_bitmask_length, + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame = { + COMMAND_CLASS_USER_CREDENTIAL, + USER_CAPABILITIES_REPORT, + (uint8_t)((number_of_users & 0xFF00) >> 8), // MSB + (uint8_t)(number_of_users & 0x00FF), // LSB + cred_rule_bitmask, + username_max_length, + (uint8_t)((support_user_schedule << 7) | (support_all_users_checksum << 6) + | (support_user_checksum << 5)), + supported_user_types_bitmask_length}; + + // Add bitmask value + for (uint8_t i = 0; i < supported_user_types_bitmask_length; i++) { + uint8_t offset = i; + uint8_t shift = 8 * offset; + uint32_t bitmask = 0xFF << shift; + + uint8_t value_8bit = (supported_user_types_bitmask & bitmask) >> shift; + report_frame.push_back(value_8bit); + } + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +} + +void helper_simulate_credential_capabilites_report( + uint8_t credential_checksum_support, + std::vector credential_type, + std::vector cl_support, + std::vector supported_credential_slots, + std::vector min_length, + std::vector max_length, + std::vector cl_timeout, + std::vector cl_steps + ) +{ + if (credential_type.size() != cl_support.size() + || credential_type.size() != supported_credential_slots.size() + || credential_type.size() != min_length.size() + || credential_type.size() != max_length.size() + || credential_type.size() != cl_timeout.size() + || credential_type.size() != cl_steps.size()) { + TEST_FAIL_MESSAGE("Size of credential_type, cl_support, " + "supported_credential_slots, min_length, max_length, " + "cl_timeout and cl_steps" + "should be the same."); + } + + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, + CREDENTIAL_CAPABILITIES_REPORT, + (uint8_t)(credential_checksum_support << 7), + (uint8_t)credential_type.size()}; + + auto push_uint16 = [&](std::vector vector) { + for (auto &v: vector) { + report_frame.push_back((uint8_t)((v & 0xFF00) >> 8)); + report_frame.push_back((uint8_t)(v & 0x00FF)); + } + }; + + for (auto &c: credential_type) { + report_frame.push_back(c); + } + + for (auto &cl: cl_support) { + report_frame.push_back((uint8_t)(cl << 7)); + } + + push_uint16(supported_credential_slots); + push_uint16(min_length); + push_uint16(max_length); + + for (auto &c: cl_timeout) { + report_frame.push_back(c); + } + + for (auto &c: cl_steps) { + report_frame.push_back(c); + } + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +}; /** * @brief Create credential structure and return associated nodes * @@ -514,39 +622,17 @@ void test_user_credential_user_capabilities_report_happy_case() uint8_t supported_user_types_bitmask_length; user_credential_supported_user_type_bitmask_t supported_user_types_bitmask; - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - // Test reported values based on the variables in this function auto test_reported_values = [&]() { // Create frame object - std::vector report_frame = { - COMMAND_CLASS_USER_CREDENTIAL, - USER_CAPABILITIES_REPORT, - (uint8_t)((number_of_users & 0xFF00) >> 8), // MSB - (uint8_t)(number_of_users & 0x00FF), // LSB - cred_rule_bitmask, - username_max_length, - (uint8_t)((support_user_schedule << 7) | (support_all_users_checksum << 6) - | (support_user_checksum << 5)), - supported_user_types_bitmask_length}; - - // Add bitmask value - for (uint8_t i = 0; i < supported_user_types_bitmask_length; i++) { - uint8_t offset = i; - uint8_t shift = 8 * offset; - uint32_t bitmask = 0xFF << shift; - - uint8_t value_8bit = (supported_user_types_bitmask & bitmask) >> shift; - report_frame.push_back(value_8bit); - } - - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); // Define data structures std::map uint8_attribute_map = { @@ -624,52 +710,14 @@ void test_user_credential_credential_capabilities_get_happy_case() void test_user_credential_credential_capabilities_report_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - auto create_report_frame - = [&](uint8_t credential_checksum_support, - std::vector credential_type, - std::vector cl_support, - std::vector supported_credential_slots, - std::vector min_length, - std::vector max_length) { - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, - CREDENTIAL_CAPABILITIES_REPORT, - (uint8_t)(credential_checksum_support << 7), - (uint8_t)credential_type.size()}; - - auto push_uint16 = [&](std::vector vector) { - for (auto &v: vector) { - report_frame.push_back((uint8_t)((v & 0xFF00) >> 8)); - report_frame.push_back((uint8_t)(v & 0x00FF)); - } - }; - - for (auto &c: credential_type) { - report_frame.push_back(c); - } - - for (auto &cl: cl_support) { - report_frame.push_back((uint8_t)(cl << 7)); - } - - push_uint16(supported_credential_slots); - push_uint16(min_length); - push_uint16(max_length); - - return report_frame; - }; - uint8_t credential_checksum_support = 1; std::vector credential_type = {1, 3, 4, 5}; std::vector cl_support = {1, 0, 0, 1}; std::vector supported_credential_slots = {1233, 11233, 21233, 33}; std::vector min_length = {2, 2362, 255, 1255}; std::vector max_length = {5632, 15632, 25632, 32568}; + std::vector cl_timeout = {100, 0, 0, 128}; + std::vector cl_steps = {2, 0, 0, 12}; uint16_t expected_credential_type_mask = 0b11101; auto test_report_values = [&]() { @@ -703,7 +751,9 @@ void test_user_credential_credential_capabilities_report_happy_case() "Incorrect credential type"); uint8_attribute_map = { - {ATTRIBUTE(CREDENTIAL_LEARN_READ_BACK_SUPPORT), cl_support[i]}, + {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), cl_support[i]}, + {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), cl_timeout[i]}, + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), cl_steps[i]}, }; uint16_attribute_map = { {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), @@ -717,37 +767,36 @@ void test_user_credential_credential_capabilities_report_happy_case() }; printf("Test with first set of data\n"); - auto report_frame = create_report_frame(credential_checksum_support, - credential_type, - cl_support, - supported_credential_slots, - min_length, - max_length); - - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_simulate_credential_capabilites_report(credential_checksum_support, + credential_type, + cl_support, + supported_credential_slots, + min_length, + max_length, + cl_timeout, + cl_steps); test_report_values(); printf("Test with second set of data\n"); - credential_checksum_support = 0; - credential_type = {6, 7, 8}; - cl_support = {0, 1, 1}; - supported_credential_slots = {15, 1565, 153}; - min_length = {155, 15, 5}; - max_length = {1111, 111, 11}; - report_frame = create_report_frame(credential_checksum_support, - credential_type, - cl_support, - supported_credential_slots, - min_length, - max_length); + credential_checksum_support = 0; + credential_type = {6, 7, 8}; + cl_support = {0, 1, 1}; + supported_credential_slots = {15, 1565, 153}; + min_length = {155, 15, 5}; + max_length = {1111, 111, 11}; + cl_timeout = {0, 10, 12}; + cl_steps = {0, 1, 2}; expected_credential_type_mask = 0b11100000; - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_simulate_credential_capabilites_report(credential_checksum_support, + credential_type, + cl_support, + supported_credential_slots, + min_length, + max_length, + cl_timeout, + cl_steps); test_report_values(); } @@ -1056,8 +1105,8 @@ void test_user_credential_user_report_happy_case() constexpr user_credential_user_unique_id_t EXPECTED_FIRST_USER_ID = 12; constexpr user_credential_user_unique_id_t EXPECTED_SECOND_USER_ID = 1212; - user_credential_user_unique_id_t next_user_id = EXPECTED_SECOND_USER_ID; - user_credential_modifier_type_t user_modifier_type = 2; + user_credential_user_unique_id_t next_user_id = EXPECTED_SECOND_USER_ID; + user_credential_modifier_type_t user_modifier_type = 2; user_credential_modifier_node_id_t user_modifier_node_id = 1313; user_credential_user_unique_id_t user_id = EXPECTED_FIRST_USER_ID; user_credential_user_type_t user_type = 3; @@ -1705,8 +1754,8 @@ void test_user_credential_credential_report_happy_case() std::vector credential_data = {12, 13, 14, 15, 16}; user_credential_modifier_type_t credential_modifier_type = 13; user_credential_modifier_node_id_t credential_modifier_node_id = 1312; - user_credential_type_t next_credential_type = 12; - user_credential_slot_t next_credential_slot = 1; + user_credential_type_t next_credential_type = 12; + user_credential_slot_t next_credential_slot = 1; auto test_user_values = [&](attribute_store_node_t credential_type_node, attribute_store_node_t credential_slot_node) { @@ -2158,6 +2207,25 @@ void test_user_credential_user_notification_add_modify_delete_happy_case() TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); + // Those functions are exposed and checks user values, so we need to setup the capabilities + uint16_t number_of_users = 12; + user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; + uint8_t username_max_length = 112; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 2; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 0xFF; + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + // Setup user user_credential_user_unique_id_t user_id = 12; user_credential_type_t user_type = 2; @@ -2325,6 +2393,23 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() &user_id, sizeof(user_id)); + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); + // Add credential sl_status_t status = zwave_command_class_user_credential_add_new_credential( endpoint_id_node, @@ -2395,7 +2480,6 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() test_attribute_store_values(); crb = false; - ; credential_data = "121212"; credential_modifier_type = 3; credential_modifier_node_id = 15; @@ -2433,4 +2517,487 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() "User ID node should still exist"); } +void test_user_credential_user_add_capabilites_failure_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + // Those functions are exposed and checks user values, so we need to setup the capabilities + uint16_t number_of_users = 1; + user_credential_supported_credential_rules_t cred_rule_bitmask = 2; + uint8_t username_max_length = 1; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 1; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 1; + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + + // User ID not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_user(endpoint_id_node, + 12, // User ID + 0, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), + "User ID is not valid"); + + // User Type not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_user(endpoint_id_node, + 1, // User ID + 1, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), + "User Type is not valid"); + + // Credential rule not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_user(endpoint_id_node, + 1, // User ID + 0, // User Type + 2, // Credential rule + 1, + 0, + 0, + "G"), + "Credential rule is not valid"); + + // Username too long + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_user(endpoint_id_node, + 1, // User ID + 0, // User Type + 1, // Credential rule + 1, + 0, + 0, + "GERARD TURBO"), + "User name is not valid"); +} + +void test_user_credential_user_add_capabilites_happy_cred_rule_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + uint16_t number_of_users = 1; + uint8_t username_max_length = 1; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 1; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 1; + + std::map cred_rule_map + = { + {0x02, 1}, + {0x04, 2}, + {0x08, 3}, + {0x06, 1}, + {0x06, 2}, + {0x0F, 3}, + {0x0F, 2}, + {0x0F, 1}, + }; + + for (auto &cred_rule: cred_rule_map) { + helper_simulate_user_capabilites_report(number_of_users, + cred_rule.first, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + + printf("Testing bitmask %d with value %d\n", + cred_rule.first, + cred_rule.second); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + zwave_command_class_user_credential_add_new_user( + endpoint_id_node, + 1, // User ID + 0, // User Type + cred_rule.second, // Credential rule + 1, + 0, + 0, + "G"), + "Should be able to add user"); + } +} + +void test_user_credential_user_add_capabilites_happy_user_type_rule_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + uint16_t number_of_users = 1; + uint8_t username_max_length = 1; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 1; + user_credential_supported_credential_rules_t cred_rule = 0x02; + + std::map type_rule_map + = { + {0x01, 0}, + {0x02, 1}, + {0x04, 2}, + {0x08, 3}, + {0x06, 1}, + {0x06, 2}, + {0x0F, 3}, + {0x0F, 2}, + {0x0F, 1}, + }; + + for (auto &type_rule: type_rule_map) { + helper_simulate_user_capabilites_report(number_of_users, + cred_rule, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + type_rule.first); + + printf("Testing bitmask %d with value %d\n", + type_rule.first, + type_rule.second); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + zwave_command_class_user_credential_add_new_user( + endpoint_id_node, + 1, // User ID + type_rule.second, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), + "Should be able to add user"); + } +} + +void test_user_credential_user_modify_capabilites_failure_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + // Those functions are exposed and checks user values, so we need to setup the capabilities + uint16_t number_of_users = 1; + user_credential_supported_credential_rules_t cred_rule_bitmask = 2; + uint8_t username_max_length = 1; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 1; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 1; + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + + // User ID not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + zwave_command_class_user_credential_add_new_user(endpoint_id_node, + 1, // User ID + 0, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), + "Should be able to add user"); + + // User Type not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_user(endpoint_id_node, + 1, // User ID + 1, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), + "User Type is not valid"); + + // Credential rule not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_user(endpoint_id_node, + 1, // User ID + 0, // User Type + 2, // Credential rule + 1, + 0, + 0, + "G"), + "Credential rule is not valid"); + + // Username too long + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_user(endpoint_id_node, + 1, // User ID + 0, // User Type + 1, // Credential rule + 1, + 0, + 0, + "GERARD TURBO"), + "User name is not valid"); +} + + +void test_user_credential_credential_add_capabilites_failure_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_id = 12; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); + + // Credential type not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_PIN_CODE, // Credential type + 1, // Credential slot + "12"), + "Credential type shouldn't be valid"); + + // Credential slot not valid + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 2, // Credential slot + "12"), + "Credential slot shouldn't be valid"); + + + // Credential data too short + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "1"), + "Credential data should be too short"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "TURBO TROP LONG VROUM"), + "Credential data should be too long"); +} + +void test_user_credential_credential_add_capabilites_happy_case() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_id = 12; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_HAND_BIOMETRIC, ZCL_CRED_TYPE_PIN_CODE}; + std::vector supported_cl = {1, 0}; + std::vector supported_credential_slots = {1, 5}; + std::vector supported_cred_min_length = {2, 4}; + std::vector supported_cred_max_length = {6, 8}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1, 1}, + {1, 1}); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "TURBO"), + "Credential #1 should be valid"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_PIN_CODE, + 4, + "121212"), + "Credential #2 should be valid"); +} + + +void test_user_credential_credential_modify_capabilites_failure_cases() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_id = 12; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {7}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + zwave_command_class_user_credential_add_new_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "VOITURE"), + "Should be able to add credential"); + + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "V"), + "Should not be able to modify credential data : it's too short"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_credential(endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "MAX SPEEEEEEEEEEEEED TURBO"), + "Should not be able to modify credential data : it's too long"); +} + + // Credential } // extern "C" \ No newline at end of file From 8d54f79ba673e9f19d4c9c09d0177bc1f94ccaa0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 22 Apr 2024 15:12:59 +0200 Subject: [PATCH 08/60] UIC-3222: Fix User post-interview discovery This patch will : - Not delete all user database en Unify startup - Allow the user to re-initiate an interview with the device and discover again all users --- .../zwave_command_class_user_credential.cpp | 47 ++++++++++++------- ...ave_command_class_user_credential_test.cpp | 42 ++++++++++++----- 2 files changed, 58 insertions(+), 31 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index adf95131d..038929c11 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -2344,9 +2344,29 @@ static sl_status_t zwave_command_class_user_credential_user_get( sl_status_t status = attribute_store_get_desired(node, &user_id, sizeof(user_id)); + // If we enter this state it means that something went badly wrong or + // user initiate the interview process again. + // In both cases we want to invalidate the user database so that the device + // can send us the correct user database. if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get user unique id value. Not sending USER_GET."); + sl_log_warning(LOG_TAG, + "Can't get user unique id value. Reset user database."); + attribute_store_node_t endpoint_node + = attribute_store_get_node_parent(node); + // Get User node count + auto user_count = attribute_store_get_node_child_count_by_type( + endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + for (size_t j = 0; j < user_count; j++) { + // Delete the first attribute we find until we have no more left + attribute_store_node_t user_node + = attribute_store_get_node_child_by_type(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + 0); + attribute_store_delete_node(user_node); + } + // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. return SL_STATUS_NOT_SUPPORTED; } @@ -2576,23 +2596,14 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, auto user_count = attribute_store_get_node_child_count_by_type( endpoint_node, ATTRIBUTE(USER_UNIQUE_ID)); - sl_log_debug(LOG_TAG, - "Endpoint %d supports User Credential. Removing all " - "existing user nodes (%d)...", - i, - user_count); - for (size_t j = 0; j < user_count; j++) { - // Delete the first attribute we find until we have no more left - attribute_store_node_t user_node - = attribute_store_get_node_child_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - 0); - attribute_store_delete_node(user_node); + sl_log_debug(LOG_TAG, "Endpoint %d supports User Credential.", endpoint_id); + if (user_count == 0) { + sl_log_debug(LOG_TAG, "No user found. Starting User and Credential interview"); + // Start the interview process with user ID = 0 + trigger_get_user(endpoint_node, 0); + } else { + sl_log_debug(LOG_TAG, "Users already discovered. No actions needed."); } - - sl_log_debug(LOG_TAG, "Starting User and Credential interview"); - // Start the interview process with user ID = 0 - trigger_get_user(endpoint_node, 0); } } } diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 4f26f7851..9fbbc06d2 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2124,18 +2124,6 @@ void test_post_interview_discovery() // Display current store log for debug purpose attribute_store_log(); - // Set two random user id to see if discovery remove it - user_credential_user_unique_id_t user_id = 12; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - user_id = 1222; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - // Set the network status to online network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; attribute_store_set_reported(network_status_node, @@ -2146,13 +2134,41 @@ void test_post_interview_discovery() auto user_id_node = attribute_store_get_first_child_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID)); - + user_credential_user_unique_id_t user_id = 0; attribute_store_get_desired(user_id_node, &user_id, sizeof(user_id)); TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, user_id_node, "User id node should exists"); TEST_ASSERT_EQUAL_MESSAGE(0, user_id, "User ID desired value should be 0"); count_user_node(1); + + // Simulate user found + user_id = 12; + attribute_store_set_reported(user_id_node, &user_id, sizeof(user_id)); + + // Go back to Interview state + network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_INTERVIEWING; + attribute_store_set_reported(network_status_node, + &network_status, + sizeof(network_status)); + + // Then back in Online Functional + network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; + attribute_store_set_reported(network_status_node, + &network_status, + sizeof(network_status)); + // User should still be there + count_user_node(1); + // With right value + user_credential_user_unique_id_t reported_user_id = 0; + user_id_node = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); + attribute_store_get_reported(user_id_node, + &reported_user_id, + sizeof(reported_user_id)); + TEST_ASSERT_EQUAL_MESSAGE(user_id, + reported_user_id, + "User ID reported value should be 12."); } void test_user_credential_notification_empty_parameters() From 715553777ebe7b54a396af301271f31d696da965 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 25 Apr 2024 12:01:31 +0200 Subject: [PATCH 09/60] UIC-3222: User Set Error Report Command --- .../zwave_command_class_user_credential.cpp | 69 ++++- ...ave_command_class_user_credential_test.cpp | 292 +++++++++++++----- 2 files changed, 283 insertions(+), 78 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 038929c11..b8c16deed 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -2230,7 +2230,7 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( } ///////////////////////////////////////////////////////////////////////////// -// User Set/Get/Report +// User Set/Get/Report/Set Error Report ///////////////////////////////////////////////////////////////////////////// // Start user interview process by starting a user get with ID 0 @@ -2540,6 +2540,68 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length < 14) { + sl_log_warning(LOG_TAG, "USER_SET_ERROR_REPORT frame length is not valid"); + return SL_STATUS_NOT_SUPPORTED; + } + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // We don't need the rest of the frame, we just ensure that the attribute store is in a valid state + uint8_t error_code = frame_data[2]; + user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 6); + + auto remove_user_node_if_possible = + [&](attribute_store_node_t user_unique_id_node) { + if (attribute_store_node_exists(user_unique_id_node)) { + sl_log_debug(LOG_TAG, "Remove faulty user state", user_id); + attribute_store_delete_node(user_unique_id_node); + } else { + sl_log_debug( + LOG_TAG, + "Didn't find an user with id %d in desired state. Not doing anything", + user_id); + } + }; + + // This case should not happens often since we are doing preemptive checks + switch (error_code) { + // USER_ADD_REJECTED_LOCATION_OCCUPIED : 0x00 + //A user add operation is rejected due to the User Unique Identifier already being occupied + case USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED: { + sl_log_error(LOG_TAG, + "Error when setting user : user ID %d is not available. Try " + "to modify it instead.", + user_id); + // It should be in desired state since we are using ADD operation + attribute_store_node_t user_unique_id_node + = get_desired_user_id_node(endpoint_node, user_id); + remove_user_node_if_possible(user_unique_id_node); + } break; + // USER_MODIFY_REJECTED_LOCATION_EMPTY : 0x01 + // A user modify operation is rejected due to the User Unique Identifier location being empty + case USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY: { + sl_log_error(LOG_TAG, + "Error when modifying user : user ID %d does not exists.", + user_id); + // Hunt down the invalid user ID and remove it + attribute_store_node_t user_unique_id_node + = get_desired_user_id_node(endpoint_node, user_id); + // Check for reported value if it doesn't exists + if (!attribute_store_node_exists(user_unique_id_node)) { + user_unique_id_node = get_reported_user_id_node(endpoint_node, user_id); + } + remove_user_node_if_possible(user_unique_id_node); + } break; + } + + return SL_STATUS_OK; +} ///////////////////////////////////////////////////////////////////////////// // Post interview actions ///////////////////////////////////////////////////////////////////////////// @@ -3172,6 +3234,11 @@ sl_status_t zwave_command_class_user_credential_control_handler( } switch (frame_data[COMMAND_INDEX]) { + case USER_SET_ERROR_REPORT: + return zwave_command_class_user_credential_user_set_error_handle_report( + connection_info, + frame_data, + frame_length); case USER_CAPABILITIES_REPORT: return zwave_command_class_user_credential_user_capabilities_handle_report( connection_info, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 9fbbc06d2..23408b786 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -137,6 +137,57 @@ struct credential_structure_nodes { attribute_store_node_t credential_slot_node; }; +void helper_simulate_user_set_error_report( + uint8_t user_set_error_type, + user_credential_modifier_type_t user_modifier_type, + user_credential_modifier_node_id_t user_modifier_node_id, + user_credential_user_unique_id_t user_id, + user_credential_user_type_t user_type, + user_credential_user_active_state_t user_active_state, + user_credential_supported_credential_rules_t credential_rule, + user_credential_expiring_timeout_minutes_t expiring_timeout_minutes, + user_credential_user_name_encoding_t user_name_encoding, + std::string user_name) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, USER_SET_ERROR_REPORT}; + + report_frame.push_back(user_set_error_type); + report_frame.push_back(user_modifier_type); + + auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); + report_frame.push_back(exploded_user_modifier_node_id.msb); + report_frame.push_back(exploded_user_modifier_node_id.lsb); + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(user_type); + report_frame.push_back(user_active_state); + report_frame.push_back(credential_rule); + + auto exploded_expiring_timeout_minutes + = explode_uint16(expiring_timeout_minutes); + report_frame.push_back(exploded_expiring_timeout_minutes.msb); + report_frame.push_back(exploded_expiring_timeout_minutes.lsb); + + report_frame.push_back((uint8_t)user_name.size()); + for (const char &c: user_name) { + report_frame.push_back(c); + } + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +} + void helper_simulate_user_capabilites_report( uint16_t number_of_users, user_credential_supported_credential_rules_t cred_rule_bitmask, @@ -2161,8 +2212,9 @@ void test_post_interview_discovery() count_user_node(1); // With right value user_credential_user_unique_id_t reported_user_id = 0; - user_id_node = attribute_store_get_first_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + user_id_node + = attribute_store_get_first_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)); attribute_store_get_reported(user_id_node, &reported_user_id, sizeof(reported_user_id)); @@ -2495,7 +2547,7 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() }; test_attribute_store_values(); - crb = false; + crb = false; credential_data = "121212"; credential_modifier_type = 3; credential_modifier_node_id = 15; @@ -2767,8 +2819,8 @@ void test_user_credential_user_modify_capabilites_failure_cases() SL_STATUS_OK, zwave_command_class_user_credential_add_new_user(endpoint_id_node, 1, // User ID - 0, // User Type - 1, // Credential rule + 0, // User Type + 1, // Credential rule 1, 0, 0, @@ -2779,43 +2831,42 @@ void test_user_credential_user_modify_capabilites_failure_cases() TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, zwave_command_class_user_credential_modify_user(endpoint_id_node, - 1, // User ID - 1, // User Type - 1, // Credential rule - 1, - 0, - 0, - "G"), + 1, // User ID + 1, // User Type + 1, // Credential rule + 1, + 0, + 0, + "G"), "User Type is not valid"); // Credential rule not valid TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, zwave_command_class_user_credential_modify_user(endpoint_id_node, - 1, // User ID - 0, // User Type - 2, // Credential rule - 1, - 0, - 0, - "G"), + 1, // User ID + 0, // User Type + 2, // Credential rule + 1, + 0, + 0, + "G"), "Credential rule is not valid"); // Username too long TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, zwave_command_class_user_credential_modify_user(endpoint_id_node, - 1, // User ID - 0, // User Type - 1, // Credential rule - 1, - 0, - 0, - "GERARD TURBO"), + 1, // User ID + 0, // User Type + 1, // Credential rule + 1, + 0, + 0, + "GERARD TURBO"), "User name is not valid"); } - void test_user_credential_credential_add_capabilites_failure_cases() { // Initialize the notification callback @@ -2856,40 +2907,43 @@ void test_user_credential_credential_add_capabilites_failure_cases() // Credential type not valid TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_PIN_CODE, // Credential type - 1, // Credential slot - "12"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_PIN_CODE, // Credential type + 1, // Credential slot + "12"), "Credential type shouldn't be valid"); // Credential slot not valid TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 2, // Credential slot - "12"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 2, // Credential slot + "12"), "Credential slot shouldn't be valid"); - // Credential data too short TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "1"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "1"), "Credential data should be too short"); TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "TURBO TROP LONG VROUM"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "TURBO TROP LONG VROUM"), "Credential data should be too long"); } @@ -2932,23 +2986,24 @@ void test_user_credential_credential_add_capabilites_happy_case() TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "TURBO"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "TURBO"), "Credential #1 should be valid"); TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_PIN_CODE, - 4, - "121212"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_PIN_CODE, + 4, + "121212"), "Credential #2 should be valid"); } - void test_user_credential_credential_modify_capabilites_failure_cases() { @@ -2988,32 +3043,115 @@ void test_user_credential_credential_modify_capabilites_failure_cases() {1}); TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - zwave_command_class_user_credential_add_new_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "VOITURE"), + zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "VOITURE"), "Should be able to add credential"); - TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_modify_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "V"), - "Should not be able to modify credential data : it's too short"); + zwave_command_class_user_credential_modify_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "V"), + "Should not be able to modify credential data : it's too short"); TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, - zwave_command_class_user_credential_modify_credential(endpoint_id_node, - user_id, - ZCL_CRED_TYPE_HAND_BIOMETRIC, - 1, - "MAX SPEEEEEEEEEEEEED TURBO"), + zwave_command_class_user_credential_modify_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "MAX SPEEEEEEEEEEEEED TURBO"), "Should not be able to modify credential data : it's too long"); } - // Credential +void test_user_credential_user_set_error_report_user_add_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + + // Simulate invalid user + auto invalid_user_node + = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + auto valid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + helper_simulate_user_set_error_report( + USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED, + 1, + 2, + user_id, + 1, + 0, + 1, + 0, + 0, + "TAJINE AUX EPICES"); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), + "Invalid User node should not exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid User node should exist"); +} + +void test_user_credential_user_set_error_report_user_modify_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + + // Simulate invalid user (desired) + auto invalid_user_node + = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + helper_simulate_user_set_error_report( + USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY, + 1, + 2, + user_id, + 1, + 0, + 1, + 0, + 0, + "SAUCISSE FUMEE"); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), + "Invalid User node should not exist"); + + // Simulate invalid user (reported) + invalid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + helper_simulate_user_set_error_report( + USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY, + 1, + 2, + user_id, + 1, + 0, + 1, + 0, + 0, + "TURBO BARBEUC"); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), + "Invalid User node should not exist"); +} + } // extern "C" \ No newline at end of file From 15b7e3e1b12aba2c43f960859c4c88265727e5cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 25 Apr 2024 15:32:40 +0200 Subject: [PATCH 10/60] UIC-3222: Credential Set Error Report Command Also remove credential if modifier type is DNE --- .../zwave_command_class_user_credential.cpp | 184 +++++++++++ ...ave_command_class_user_credential_test.cpp | 298 ++++++++++++++++++ 2 files changed, 482 insertions(+) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index b8c16deed..679b64f00 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -1012,6 +1012,11 @@ user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) { return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); } +user_credential_modifier_type_t get_credential_modifier_type(const uint8_t *event_parameters) +{ + // TODO : Update this with the new specification where CREDENTIAL_DATA doesn't exists anymore + return event_parameters[8]; +} attribute_store_node_t get_credential_type_node(attribute_store_node_t endpoint_node, @@ -1446,6 +1451,50 @@ void on_notification_event(attribute_store_node_t endpoint_node, credential_slot, user_id); } break; + // Credential unchanged + case 0x2E: { + sl_log_debug(LOG_TAG, "Notification : Credential Unchanged"); + if (!notification_handler::credential::is_report_size_conform( + event_parameters_length)) { + return; + } + + // Used in logs + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type( + event_parameters); + user_credential_slot_t credential_slot + = notification_handler::credential::get_credential_slot( + event_parameters); + user_credential_user_unique_id_t user_id + = notification_handler::credential::get_user_id(event_parameters); + + // Type and slot + auto credential_slot_node = get_credential_slot_node_by_type(); + if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { + return; + } + + // If user doesn't exists in the device we try to remove it also from our side + user_credential_modifier_type_t modifier_type + = notification_handler::credential::get_credential_modifier_type(event_parameters); + if (modifier_type == CREDENTIAL_REPORT_DNE) { + attribute_store_delete_node(credential_slot_node); + } else { + sl_log_info(LOG_TAG, + "Credential Unchanged, clearing desired values. For Type " + "%d, Slot %d (User %d)", + credential_type, + credential_slot, + user_id); + + attribute_store_undefine_desired(credential_slot_node); + attribute_store_undefine_desired( + attribute_store_get_node_child_by_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA), + 0)); + } + } break; default: break; } @@ -2156,6 +2205,19 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return SL_STATUS_NOT_SUPPORTED; } + // Remove node if it doesn't exist anymore on the end device + if (frame_data[INDEX_CREDENTIAL_MODIFIER_TYPE] == CREDENTIAL_REPORT_DNE) { + sl_log_info( + LOG_TAG, + "Credential Node %d (credential type %d, user %d) doesn't exist " + "anymore, removing it", + credential_slot, + credential_type, + user_id); + attribute_store_delete_node(credential_slot_node); + return SL_STATUS_OK; + } + // Update credential slot node & type attribute_store_set_reported(credential_type_node, &credential_type, @@ -2229,6 +2291,123 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_credential_set_error_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length < 13) { + sl_log_warning(LOG_TAG, + "CREDENTIAL_SET_ERROR_REPORT frame length is not valid"); + return SL_STATUS_NOT_SUPPORTED; + } + + // We don't need the rest of the frame, we just ensure that the attribute store is valid + uint8_t error_code = frame_data[2]; + user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 3); + user_credential_type_t credential_type = frame_data[5]; + user_credential_slot_t credential_slot = get_uint16_value(frame_data, 6); + + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + attribute_store_node_t credential_type_node; + attribute_store_node_t credential_slot_node; + + auto remove_credential_slot_if_possible = [&](attribute_store_node_t credential_slot_node) { + if (attribute_store_node_exists(credential_slot_node)) { + sl_log_debug(LOG_TAG, + "Removing credential slot : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + attribute_store_delete_node(credential_slot_node); + } else { + sl_log_debug(LOG_TAG, + "No credential slot found for user %d, credential type " + "%d, credential slot %d", + user_id, + credential_type, + credential_slot); + } + }; + switch(error_code) { + // Credential Add Rejected Location Occupied : 0x00 + // If attempting to add a credential where a credential of that Credential Type at that Credential Slot already exists, and the new credential data differs + case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALADDREJECTEDLOCATIONOCCUPIED: + sl_log_error(LOG_TAG, + "Credential data rejected as it already exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + // Try to find the node in the store + get_credential_type_node(endpoint_node, user_id, credential_type, DESIRED_ATTRIBUTE, credential_type_node); + if (!attribute_store_node_exists(credential_type_node)) { + get_credential_type_node(endpoint_node, user_id, credential_type, REPORTED_ATTRIBUTE, credential_type_node); + } + + get_credential_slot_node(credential_type_node, credential_slot, DESIRED_ATTRIBUTE, credential_slot_node); + + remove_credential_slot_if_possible(credential_slot_node); + break; + // Credential Modify Rejected Location Empty : 0x01 + case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY: + sl_log_error(LOG_TAG, + "Credential data cannot be modified as it does not exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + + // Try to find the node in the store + get_credential_type_node(endpoint_node, user_id, credential_type, DESIRED_ATTRIBUTE, credential_type_node); + if (!attribute_store_node_exists(credential_type_node)) { + get_credential_type_node(endpoint_node, user_id, credential_type, REPORTED_ATTRIBUTE, credential_type_node); + } + + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_debug(LOG_TAG, + "No credential type found for user %d, credential type %d", + user_id, + credential_type); + return SL_STATUS_OK; + } + + get_credential_slot_node(credential_type_node, credential_slot, DESIRED_ATTRIBUTE, credential_slot_node); + if (!attribute_store_node_exists(credential_slot_node)) { + get_credential_slot_node(credential_type_node, credential_slot, REPORTED_ATTRIBUTE, credential_slot_node); + } + + remove_credential_slot_if_possible(credential_slot_node); + break; + // Duplicate Credential : 0x02 + case CREDENTIAL_SET_ERROR_REPORT_DUPLICATECREDENTIAL: + // Do nothing, the credential GET will clean up for us + sl_log_warning(LOG_TAG, + "Duplicate Credential for user %d, credential type %d, " + "credential slot %d", + user_id, + credential_type, + credential_slot); + break; + // Manufacturer Security Rules : 0x03 + case CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES: + // Do nothing, the credential GET will clean up for us + sl_log_warning( + LOG_TAG, + "Credential data rejected as it doesn't respect manufacturer " + "security rules : user %d, credential type %d, " + "credential slot %d", + user_id, + credential_type, + credential_slot); + break; + } + + return SL_STATUS_OK; +} ///////////////////////////////////////////////////////////////////////////// // User Set/Get/Report/Set Error Report ///////////////////////////////////////////////////////////////////////////// @@ -3239,6 +3418,11 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case CREDENTIAL_SET_ERROR_REPORT: + return zwave_command_class_user_credential_credential_set_error_handle_report( + connection_info, + frame_data, + frame_length); case USER_CAPABILITIES_REPORT: return zwave_command_class_user_credential_user_capabilities_handle_report( connection_info, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 23408b786..0e766a965 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -188,6 +188,55 @@ void helper_simulate_user_set_error_report( handler.control_handler(&info, report_frame.data(), report_frame.size())); } +void helper_simulate_credential_set_error_report( + uint8_t credential_set_error_type, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + uint8_t crb, + std::string credential_data, + user_credential_modifier_type_t modifier_type, + user_credential_modifier_node_id_t modifier_node_id) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_SET_ERROR_REPORT}; + + report_frame.push_back(credential_set_error_type); + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(credential_type); + + auto exploded_credential_slot = explode_uint16(credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(crb << 7); + + report_frame.push_back((uint8_t)credential_data.size()); + for (const char &c: credential_data) { + report_frame.push_back(c); + } + + report_frame.push_back(modifier_type); + + auto exploded_modifier_node_id = explode_uint16(modifier_node_id); + report_frame.push_back(exploded_modifier_node_id.msb); + report_frame.push_back(exploded_modifier_node_id.lsb); + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +} + void helper_simulate_user_capabilites_report( uint16_t number_of_users, user_credential_supported_credential_rules_t cred_rule_bitmask, @@ -3154,4 +3203,253 @@ void test_user_credential_user_set_error_report_user_modify_happy_case() "Invalid User node should not exist"); } +void test_user_credential_credential_set_error_report_cred_add_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + + auto valid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + auto valid_cred_type_node + = attribute_store_emplace(valid_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + auto invalid_cred_slot_node + = attribute_store_emplace_desired(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + helper_simulate_credential_set_error_report( + CREDENTIAL_SET_ERROR_REPORT_CREDENTIALADDREJECTEDLOCATIONOCCUPIED, + user_id, + credential_type, + credential_slot, + 1, + "1212", + 1, + 2); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node should not exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); +} + +void test_user_credential_credential_set_error_report_cred_modify_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + + auto valid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + auto valid_cred_type_node + = attribute_store_emplace(valid_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + auto invalid_cred_slot_node + = attribute_store_emplace_desired(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + helper_simulate_credential_set_error_report( + CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY, + user_id, + credential_type, + credential_slot, + 1, + "1212", + 1, + 2); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node should not exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); + + invalid_cred_slot_node + = attribute_store_emplace(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + helper_simulate_credential_set_error_report( + CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY, + user_id, + credential_type, + credential_slot, + 1, + "1212", + 1, + 2); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node should not exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); +} + + +void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() { + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + + auto valid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + auto valid_cred_type_node + = attribute_store_emplace(valid_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + auto invalid_cred_slot_node + = attribute_store_emplace_desired(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + helper_simulate_credential_set_error_report( + CREDENTIAL_SET_ERROR_REPORT_DUPLICATECREDENTIAL, + user_id, + credential_type, + credential_slot, + 1, + "1212", + 1, + 2); + + // Here the Credential Report command should remove this not this report + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node SHOULD exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); + + + // Now actually send the report + std::vector cred_data = {1,2,3,4}; + auto credential_report_frame + = helper_create_credential_report_frame(user_id, + credential_type, + credential_slot, + 1, + cred_data, + CREDENTIAL_REPORT_DNE, + 2, + 0, + 0); + + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, credential_report_frame.data(), credential_report_frame.size())); + + + // Now it should not exists + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node should NOT exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); + +} + +// Note : same as test_user_credential_credential_set_error_report_cred_duplicate_happy_case +// but with CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES in the report +void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() { + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + + auto valid_user_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + auto valid_cred_type_node + = attribute_store_emplace(valid_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + auto invalid_cred_slot_node + = attribute_store_emplace_desired(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + helper_simulate_credential_set_error_report( + CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES, + user_id, + credential_type, + credential_slot, + 1, + "1212", + 1, + 2); + + // Here the Credential Report command should remove this not this report + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node SHOULD exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); + + + // Now actually send the report + std::vector cred_data = {1,2,3,4}; + auto credential_report_frame + = helper_create_credential_report_frame(user_id, + credential_type, + credential_slot, + 1, + cred_data, + CREDENTIAL_REPORT_DNE, + 2, + 0, + 0); + + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, credential_report_frame.data(), credential_report_frame.size())); + + + // Now it should not exists + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + "Invalid Credential Slot node should NOT exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + "Valid User node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + "Valid Credential type node should exist"); + +} + } // extern "C" \ No newline at end of file From a7912890e94de2fcf99f680c1989046c4f670347 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Fri, 26 Apr 2024 11:45:49 +0200 Subject: [PATCH 11/60] UIC-3222: Delete All User Command --- .../src/user_credential_cluster_server.cpp | 24 ++++++++ .../user_credential_cluster_server_test.cpp | 53 ++++++++++++++++ .../zwave_command_class_user_credential.cpp | 56 +++++++++++++++++ .../src/zwave_command_class_user_credential.h | 25 ++++++++ ...ave_command_class_user_credential_test.cpp | 60 +++++++++++++++++++ 5 files changed, 218 insertions(+) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 09e072606..b4f5f4648 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -189,6 +189,7 @@ static sl_status_t return SL_STATUS_OK; } + static sl_status_t delete_user_command(dotdot_unid_t unid, dotdot_endpoint_id_t endpoint, @@ -302,6 +303,26 @@ static sl_status_t credential_slot); } +static sl_status_t delete_all_users_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_all_users(endpoint_node); +} /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -709,6 +730,9 @@ sl_status_t user_credential_cluster_server_init() &modify_credential_command); uic_mqtt_dotdot_user_credential_delete_credential_callback_set( &delete_credential_command); + // Delete all + uic_mqtt_dotdot_user_credential_delete_all_users_callback_set( + &delete_all_users_command); return SL_STATUS_OK; } \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 35438461f..cf8df2d5e 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -75,6 +75,8 @@ uic_mqtt_dotdot_user_credential_modify_user_callback_t modify_user_command = NUL uic_mqtt_dotdot_user_credential_add_credential_callback_t add_credential_command = NULL; uic_mqtt_dotdot_user_credential_modify_credential_callback_t modify_credential_command = NULL; uic_mqtt_dotdot_user_credential_delete_credential_callback_t delete_credential_command = NULL; +uic_mqtt_dotdot_user_credential_delete_all_users_callback_t delete_all_users_command = NULL; + // clang-format on // Stub functions for intercepting callback registration. @@ -117,6 +119,12 @@ void uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub( { delete_credential_command = callback; } +void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_all_users_callback_t callback, + int cmock_num_calls) +{ + delete_all_users_command = callback; +} /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() @@ -177,6 +185,8 @@ void setUp() uic_mqtt_dotdot_user_credential_add_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_add_credential_callback_set_stub); uic_mqtt_dotdot_user_credential_modify_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_modify_credential_callback_set_stub); uic_mqtt_dotdot_user_credential_delete_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub); + // Delete all + uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub); // clang-format on // Run the component init @@ -1587,6 +1597,49 @@ void test_user_credential_cluster_delete_credential_happy_case() USER_CREDENTIAL_OPERATION_TYPE_DELETE); } +void test_user_credential_cluster_delete_all_users_happy_case() +{ + // Simulate user + user_credential_user_unique_id_t user_unique_id = 12; + UserTypeEnum user_type = ZCL_USER_TYPE_ENUM_EXPIRING_USER; + CredRule credential_rule = ZCL_CRED_RULE_SINGLE; + bool user_active_state = true; + uint16_t expiring_timeout = 50; + UserNameEncodingType user_name_encoding = ZCL_USER_NAME_ENCODING_TYPE_ASCII; + const char *user_name = "RIP JACKIE TUNNING"; + + helper_add_complete_user(user_unique_id, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_all_users_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + "Should be able to setup attribute store for all user deletion"); + + + user_unique_id = 0; + auto deletion_user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t*)&user_unique_id, + sizeof(user_unique_id), + 0); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), + "Should be one user node with desired value of 0 to perform user interview"); + helper_test_operation_type(deletion_user_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + + /////////////////////////////////////////////////// // Support tests /////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 679b64f00..5995de69b 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -67,6 +67,18 @@ * */ +///////////////////////////////////////////////////////////////////////////// +// Preemptive declarations +///////////////////////////////////////////////////////////////////////////// +/** + * @brief Trigger an User Get for given user_id + * + * @param endpoint_node Endpoint node + * @param user_id User ID. Can be set to 0 to discover users +*/ +void trigger_get_user(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + ///////////////////////////////////////////////////////////////////////////// // Data struct ///////////////////////////////////////////////////////////////////////////// @@ -1495,6 +1507,29 @@ void on_notification_event(attribute_store_node_t endpoint_node, 0)); } } break; + // All user deleted + case 0x25: { + sl_log_debug(LOG_TAG, "Notification : All User Deleted"); + + // Delete all user nodes + auto user_node_count = attribute_store_get_node_child_count_by_type( + endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + for (size_t i = 0; i < user_node_count; i++) { + attribute_store_node_t user_node + = attribute_store_get_node_child_by_type( + endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + 0); // 0 not i here since user will be deleted + attribute_store_delete_node(user_node); + } + sl_log_info(LOG_TAG, "All credentials deleted."); + + sl_log_debug(LOG_TAG, + "Interview users again to make sure they are not any left."); + trigger_get_user(endpoint_node, 0); + } break; default: break; } @@ -3398,6 +3433,27 @@ sl_status_t zwave_command_class_user_credential_delete_credential( return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_delete_all_users( + attribute_store_node_t endpoint_node) +{ + // Send an User SET with user id = 0 + user_credential_user_unique_id_t user_id = 0; + attribute_store_node_t user_id_node + = attribute_store_emplace(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Finally set operation type delete + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, + "Delete all user operation received. Creating user with id %d " + "to send a User SET.", + user_id); + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index a2dc75450..4a376f7f0 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -163,6 +163,31 @@ sl_status_t zwave_command_class_user_credential_delete_credential( user_credential_type_t credential_type, user_credential_slot_t credential_slot); +/** + * @brief Send a delete all users command (User SET) to the end device + * + * It will send an User SET command with user id = 0 and operation type delete to remove all users. + * (CC:0083.01.05.11.009) + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_delete_all_users( + attribute_store_node_t endpoint_node); + +// sl_status_t zwave_command_class_user_credential_delete_all_credentials( +// attribute_store_node_t endpoint_node); +// sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( +// attribute_store_node_t endpoint_node, +// user_credential_user_unique_id_t user_id); +// sl_status_t +// zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( +// attribute_store_node_t endpoint_node, +// user_credential_user_unique_id_t user_id; +// user_credential_type_t credential_type); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 0e766a965..ee8429372 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -3452,4 +3452,64 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c } + +void test_user_credential_remove_all_users_happy_case() { + + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + std::vector user_ids = {12,15,19}; + for(auto user_id : user_ids) { + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + user_id); + } + + auto status + = zwave_command_class_user_credential_delete_all_users(endpoint_id_node); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Remove all users should have returned SL_STATUS_OK"); + + TEST_ASSERT_EQUAL_MESSAGE( + user_ids.size() + + 1, // +1 because the remove all users will add an extra user to invoke the user SET command + attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)), + "All users should have NOT have been removed yet"); + + // This will handle the deletion + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x25, // All User deleted + // No need to have arguments here + std::vector().data(), + 0); + + TEST_ASSERT_EQUAL_MESSAGE( + 1, // Should be one user left here with desired value of 0 + attribute_store_get_node_child_count_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID)), + "All users should have been removed yet"); + + user_credential_user_unique_id_t user_id = 0; + auto user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + DESIRED_ATTRIBUTE, + (uint8_t*)&user_id, + sizeof(user_id), + 0); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_node), + "Should be one user node with desired value of 0 to perform user interview"); +} } // extern "C" \ No newline at end of file From b14472c41aeed8194eb7e38789e6318d841281b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 22 May 2024 15:54:07 +0200 Subject: [PATCH 12/60] UIC-3222: Delete All Credentials commands UIC-3222: Documentation of delete all credentials --- .../src/user_credential_cluster_server.cpp | 109 +++++ .../user_credential_cluster_server_test.cpp | 281 +++++++++++- .../zwave_command_class_user_credential.cpp | 242 ++++++++++ .../src/zwave_command_class_user_credential.h | 77 +++- ...ave_command_class_user_credential_test.cpp | 430 ++++++++++++++++-- 5 files changed, 1092 insertions(+), 47 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index b4f5f4648..d4003d7d6 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -323,6 +323,107 @@ static sl_status_t delete_all_users_command(dotdot_unid_t unid, return zwave_command_class_user_credential_delete_all_users(endpoint_node); } + +static sl_status_t + delete_all_credentials(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_all_credentials( + endpoint_node); +} + +static sl_status_t delete_all_credentials_by_type( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_all_credentials_by_type( + endpoint_node, + static_cast(credential_type)); +} + +static sl_status_t delete_all_credentials_for_user( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_unique_id) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_all_credentials_for_user( + endpoint_node, + user_unique_id); +} + +static sl_status_t delete_all_credentials_for_user_by_type( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_unique_id, + CredType credential_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + endpoint_node, + user_unique_id, + static_cast(credential_type)); +} + /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -733,6 +834,14 @@ sl_status_t user_credential_cluster_server_init() // Delete all uic_mqtt_dotdot_user_credential_delete_all_users_callback_set( &delete_all_users_command); + uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set( + &delete_all_credentials); + uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set( + &delete_all_credentials_by_type); + uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set( + &delete_all_credentials_for_user); + uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set( + &delete_all_credentials_for_user_by_type); return SL_STATUS_OK; } \ No newline at end of file diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index cf8df2d5e..a466cd019 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -76,7 +76,10 @@ uic_mqtt_dotdot_user_credential_add_credential_callback_t add_credential_command uic_mqtt_dotdot_user_credential_modify_credential_callback_t modify_credential_command = NULL; uic_mqtt_dotdot_user_credential_delete_credential_callback_t delete_credential_command = NULL; uic_mqtt_dotdot_user_credential_delete_all_users_callback_t delete_all_users_command = NULL; - +uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t delete_all_credentials_command = NULL; +uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t delete_all_credentials_by_type_command = NULL; +uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t delete_all_credentials_for_user_command = NULL; +uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t delete_all_credentials_for_user_by_type_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -125,6 +128,31 @@ void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub( { delete_all_users_command = callback; } +void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback, + int cmock_num_calls) +{ + delete_all_credentials_command = callback; +} +void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback, + int cmock_num_calls) +{ + delete_all_credentials_by_type_command = callback; +} +void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback, + int cmock_num_calls) +{ + delete_all_credentials_for_user_command = callback; +} +void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub( + const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback, + int cmock_num_calls) +{ + delete_all_credentials_for_user_by_type_command = callback; +} + /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() @@ -187,6 +215,10 @@ void setUp() uic_mqtt_dotdot_user_credential_delete_credential_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_credential_callback_set_stub); // Delete all uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub); + uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub); // clang-format on // Run the component init @@ -1639,6 +1671,253 @@ void test_user_credential_cluster_delete_all_users_happy_case() USER_CREDENTIAL_OPERATION_TYPE_DELETE); } +void test_user_credential_cluster_delete_all_credential_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 0; + user_credential_type_t credential_type = 0; + user_credential_slot_t credential_slot = 0; + + std::vector user_ids = {12, 12, 12, 15, 19}; + std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + helper_add_complete_credential(user_ids[i], + credential_types[i], + credential_slots[i], + "1"); + } + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_all_credentials_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + "Should be able to setup attribute store for all credential deletion"); + + + auto deletion_user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto deletion_cred_type_node + = attribute_store_get_node_child_by_value(deletion_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto deletion_cred_slot_node + = attribute_store_get_node_child_by_value(deletion_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), + "User node with id 0 should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_type_node), + "Credential type node with id 0 should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_slot_node), + "Credential slot node with id 0 should exists"); + + helper_test_operation_type(deletion_cred_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + +void test_user_credential_cluster_delete_all_credential_for_user_happy_case() +{ + + user_credential_user_unique_id_t user_unique_id = 12; + user_credential_type_t credential_type = 0; + user_credential_slot_t credential_slot = 0; + + std::vector user_ids + = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; + std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + helper_add_complete_credential(user_ids[i], + credential_types[i], + credential_slots[i], + "1"); + } + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_all_credentials_for_user_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id), + "Should be able to setup attribute store for all credential deletion"); + + + auto deletion_user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto deletion_cred_type_node + = attribute_store_get_node_child_by_value(deletion_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto deletion_cred_slot_node + = attribute_store_get_node_child_by_value(deletion_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), + "User node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_type_node), + "Credential type node with id 0 should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_slot_node), + "Credential slot node with id 0 should exists"); + + helper_test_operation_type(deletion_cred_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + +void test_user_credential_cluster_delete_all_credential_for_user_by_type_happy_case() +{ + + user_credential_user_unique_id_t user_unique_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 0; + + std::vector user_ids + = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; + std::vector credential_types + = {credential_type, credential_type, 2, 5, credential_type}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + helper_add_complete_credential(user_ids[i], + credential_types[i], + credential_slots[i], + "1"); + } + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_all_credentials_for_user_by_type_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + static_cast(credential_type)), + "Should be able to setup attribute store for all credential deletion"); + + auto deletion_user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto deletion_cred_type_node + = attribute_store_get_node_child_by_value(deletion_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto deletion_cred_slot_node + = attribute_store_get_node_child_by_value(deletion_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), + "User node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_type_node), + "Credential type node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_slot_node), + "Credential slot node with id 0 should exists"); + + helper_test_operation_type(deletion_cred_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + +void test_user_credential_cluster_delete_all_credential_by_type_happy_case() +{ + + user_credential_user_unique_id_t user_unique_id = 0; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 0; + + std::vector user_ids + = {12, 12, 12, 15, 19}; + std::vector credential_types + = {credential_type, credential_type, 2, 5, credential_type}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + helper_add_complete_credential(user_ids[i], + credential_types[i], + credential_slots[i], + "1"); + } + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + delete_all_credentials_by_type_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + static_cast(credential_type)), + "Should be able to setup attribute store for all credential deletion"); + + auto deletion_user_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto deletion_cred_type_node + = attribute_store_get_node_child_by_value(deletion_user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto deletion_cred_slot_node + = attribute_store_get_node_child_by_value(deletion_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), + "User node with id 0 should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_type_node), + "Credential type node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_cred_slot_node), + "Credential slot node with id 0 should exists"); + + helper_test_operation_type(deletion_cred_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); +} + /////////////////////////////////////////////////// // Support tests diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 5995de69b..15b542b0b 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -595,6 +595,67 @@ bool get_credential_type_node(attribute_store_node_t endpoint_node, return attribute_store_node_exists(credential_type_node); } +/** + * @brief Get ALL the credential type nodes. + * + * By default it will return all the credential type nodes, but you can narrow + * to a specific credential type with the credential_type parameter + * + * @param endpoint_node Endpoint point node + * @param credential_type Credential type to find. If 0, will return all credential types + * + * @return std::vector List of credential type nodes +*/ +std::vector + get_all_credential_type_nodes(attribute_store_node_t endpoint_node, + user_credential_type_t credential_type = 0) +{ + std::vector credential_type_nodes; + + // Delete all user nodes + auto user_node_count + = attribute_store_get_node_child_count_by_type(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + for (size_t user_id_index = 0; user_id_index < user_node_count; + user_id_index++) { + attribute_store_node_t user_node + = attribute_store_get_node_child_by_type(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + user_id_index); + + auto credential_type_node_count + = attribute_store_get_node_child_count_by_type( + user_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + + for (size_t credential_index = 0; + credential_index < credential_type_node_count; + credential_index++) { + attribute_store_node_t credential_type_node + = attribute_store_get_node_child_by_type(user_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_index); + if (credential_type == 0) { + // If we haven't specify a node type we take them all + credential_type_nodes.push_back(credential_type_node); + } else { + // Otherwise we only take the ones that match + user_credential_type_t current_credential_type; + attribute_store_read_value(credential_type_node, + REPORTED_ATTRIBUTE, + ¤t_credential_type, + sizeof(current_credential_type)); + + if (current_credential_type == credential_type) { + credential_type_nodes.push_back(credential_type_node); + } + } + } + } + + return credential_type_nodes; +} /** * @brief Get credential slot node * @@ -1092,6 +1153,18 @@ bool is_report_size_conform(uint8_t event_parameters_length) return true; }; +// Only have the first 3 parameters (user id, credential type, credential slot) +// Permissive to some noise in the frame after the data we care about +bool is_credential_deletion_size_conform(uint8_t event_parameters_length) +{ + if (event_parameters_length < 5) { + sl_log_error(LOG_TAG, "Invalid Credential Event Multiple Deletion size"); + return false; + } + + return true; +}; + void update_credential_reported_values( attribute_store_node_t credential_slot_node, const uint8_t *event_parameters) { @@ -1530,6 +1603,89 @@ void on_notification_event(attribute_store_node_t endpoint_node, "Interview users again to make sure they are not any left."); trigger_get_user(endpoint_node, 0); } break; + // Multiple credential deleted + case 0x26: { + sl_log_debug(LOG_TAG, "Notification : Multiple credential deleted"); + + if (!notification_handler::credential::is_credential_deletion_size_conform( + event_parameters_length)) { + return; + } + + user_credential_user_unique_id_t user_id + = notification_handler::credential::get_user_id(event_parameters); + user_credential_type_t credential_type + = notification_handler::credential::get_credential_type( + event_parameters); + + if (user_id != 0 && credential_type != 0) { + // Delete all slots for an credential type associated with user + sl_log_debug(LOG_TAG, + "Delete all slots for credential type %d and user %d", + credential_type, + user_id); + + auto cred_type_node = notification_handler::credential::get_credential_type_node( + endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); + + if (!attribute_store_node_exists(cred_type_node)) { + sl_log_error(LOG_TAG, + "Didn't find credential type %d associated with user %d. Can't delete credentials.", + credential_type, user_id); + return; + } + + attribute_store_delete_node(cred_type_node); + + sl_log_info(LOG_TAG, + "All credentials of type %d for user %d deleted.", + credential_type, + user_id); + } else if (user_id != 0) { + // Delete all credentials for a user + auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Didn't find user ID %d. Can't delete credentials.", + user_id); + return; + } + // Delete all credential type nodes associated with this user + auto user_node_count = attribute_store_get_node_child_count_by_type( + user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + + for (size_t i = 0; i < user_node_count; i++) { + attribute_store_node_t credential_type_node + = attribute_store_get_node_child_by_type( + user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + 0); // 0 not i here since user will be deleted + attribute_store_delete_node(credential_type_node); + } + sl_log_info(LOG_TAG, "All credentials for user %d deleted.", user_id); + } else if (credential_type != 0) { + // Delete all credentials of a type + auto credential_type_nodes = get_all_credential_type_nodes(endpoint_node, credential_type); + for(auto credential_type_node : credential_type_nodes) { + attribute_store_delete_node(credential_type_node); + } + sl_log_info(LOG_TAG, "Credential of type %d deleted", credential_type); + } else { + // Delete all credentials + auto credential_type_nodes = get_all_credential_type_nodes(endpoint_node); + for(auto credential_type_node : credential_type_nodes) { + attribute_store_delete_node(credential_type_node); + } + sl_log_info(LOG_TAG, "All credentials deleted.", user_id); + } + + // Check if we still have a user 0 in the datastore, and remove it since it should not be here + auto user_0_node = get_reported_user_id_node(endpoint_node, 0); + attribute_store_delete_node(user_0_node); + } break; default: break; } @@ -3454,6 +3610,92 @@ sl_status_t zwave_command_class_user_credential_delete_all_users( return SL_STATUS_OK; } + +void trigger_credential_deletion(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + attribute_store_node_t user_id_node + = attribute_store_emplace(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + attribute_store_node_t credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + attribute_store_node_t credential_slot_node + = attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + // Finally set operation type delete + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, + "Creating user with id %d, credential type %d and slot " + "both to %d to send a Credential SET.", + user_id, + credential_type, + credential_slot); +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials( + attribute_store_node_t endpoint_node) +{ + sl_log_debug(LOG_TAG, "Delete all credential operation received"); + + trigger_credential_deletion(endpoint_node, 0, 0, 0); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials_by_type( + attribute_store_node_t endpoint_node, user_credential_type_t credential_type) +{ + sl_log_debug(LOG_TAG, + "Delete all credential of type %d operation received", + credential_type); + + trigger_credential_deletion(endpoint_node, 0, credential_type, 0); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + sl_log_debug(LOG_TAG, + "Delete all credential for user %d operation received", + user_id); + + trigger_credential_deletion(endpoint_node, user_id, 0, 0); + + return SL_STATUS_OK; +} + +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type) +{ + sl_log_debug(LOG_TAG, + "Delete all credential for user %d and credential type %d " + "operation received", + user_id, + credential_type); + + trigger_credential_deletion(endpoint_node, user_id, credential_type, 0); + + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 4a376f7f0..1ea7ce574 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -176,17 +176,72 @@ sl_status_t zwave_command_class_user_credential_delete_credential( */ sl_status_t zwave_command_class_user_credential_delete_all_users( attribute_store_node_t endpoint_node); - -// sl_status_t zwave_command_class_user_credential_delete_all_credentials( -// attribute_store_node_t endpoint_node); -// sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( -// attribute_store_node_t endpoint_node, -// user_credential_user_unique_id_t user_id); -// sl_status_t -// zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( -// attribute_store_node_t endpoint_node, -// user_credential_user_unique_id_t user_id; -// user_credential_type_t credential_type); + +/** + * @brief Send a delete all credentials command (Credential SET) to the end device + * + * It will send an Credential SET command with user_id, credential_type and credential_slot = 0 and operation type delete to remove all credentials. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_delete_all_credentials( + attribute_store_node_t endpoint_node); + +/** + * @brief Send a delete all credentials by type command (Credential SET) to the end device + * + * It will send an Credential SET command with user_id = 0 and operation type delete to remove all credentials of the specified type. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_by_type( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type); + +/** + * @brief Send a delete all credentials for user command (Credential SET) to the end device + * + * It will send an Credential SET command with credential_type and credential_slot = 0 and operation type delete to remove all credentials of the specified user. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise + * + * @note This function will not remove the user itself. + */ +sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + +/** + * @brief Send a delete all credentials for user by type command (Credential SET) to the end device + * + * It will send an Credential SET command with credential_slot = 0 and operation type delete to remove all credentials of the specified user and type. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise + * + * @note This function will not remove the user itself. +*/ +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type); sl_status_t zwave_command_class_user_credential_init(); diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index ee8429372..7db84ad2b 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -3281,11 +3281,10 @@ void test_user_credential_credential_set_error_report_cred_modify_happy_case() TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), "Valid Credential type node should exist"); - invalid_cred_slot_node - = attribute_store_emplace(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); + invalid_cred_slot_node = attribute_store_emplace(valid_cred_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); helper_simulate_credential_set_error_report( CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY, @@ -3305,8 +3304,8 @@ void test_user_credential_credential_set_error_report_cred_modify_happy_case() "Valid Credential type node should exist"); } - -void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() { +void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() +{ user_credential_user_unique_id_t user_id = 12; user_credential_type_t credential_type = 1; user_credential_slot_t credential_slot = 1; @@ -3338,15 +3337,14 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( // Here the Credential Report command should remove this not this report TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node SHOULD exist"); + "Invalid Credential Slot node SHOULD exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), "Valid User node should exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), "Valid Credential type node should exist"); - // Now actually send the report - std::vector cred_data = {1,2,3,4}; + std::vector cred_data = {1, 2, 3, 4}; auto credential_report_frame = helper_create_credential_report_frame(user_id, credential_type, @@ -3363,10 +3361,10 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( info.remote.endpoint_id = endpoint_id; info.local.is_multicast = false; // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, credential_report_frame.data(), credential_report_frame.size())); - + TEST_ASSERT_EQUAL(SL_STATUS_OK, + handler.control_handler(&info, + credential_report_frame.data(), + credential_report_frame.size())); // Now it should not exists TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), @@ -3375,12 +3373,12 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( "Valid User node should exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), "Valid Credential type node should exist"); - } // Note : same as test_user_credential_credential_set_error_report_cred_duplicate_happy_case // but with CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES in the report -void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() { +void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() +{ user_credential_user_unique_id_t user_id = 12; user_credential_type_t credential_type = 1; user_credential_slot_t credential_slot = 1; @@ -3412,15 +3410,14 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c // Here the Credential Report command should remove this not this report TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node SHOULD exist"); + "Invalid Credential Slot node SHOULD exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), "Valid User node should exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), "Valid Credential type node should exist"); - // Now actually send the report - std::vector cred_data = {1,2,3,4}; + std::vector cred_data = {1, 2, 3, 4}; auto credential_report_frame = helper_create_credential_report_frame(user_id, credential_type, @@ -3437,10 +3434,10 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c info.remote.endpoint_id = endpoint_id; info.local.is_multicast = false; // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, credential_report_frame.data(), credential_report_frame.size())); - + TEST_ASSERT_EQUAL(SL_STATUS_OK, + handler.control_handler(&info, + credential_report_frame.data(), + credential_report_frame.size())); // Now it should not exists TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), @@ -3449,12 +3446,10 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c "Valid User node should exist"); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), "Valid Credential type node should exist"); - } - -void test_user_credential_remove_all_users_happy_case() { - +void test_user_credential_remove_all_users_happy_case() +{ const zwave_cc_version_t version = 1; attribute_store_set_child_reported(endpoint_id_node, ATTRIBUTE(VERSION), @@ -3464,8 +3459,8 @@ void test_user_credential_remove_all_users_happy_case() { TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); - std::vector user_ids = {12,15,19}; - for(auto user_id : user_ids) { + std::vector user_ids = {12, 15, 19}; + for (auto user_id: user_ids) { attribute_store_emplace(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), &user_id, @@ -3475,9 +3470,10 @@ void test_user_credential_remove_all_users_happy_case() { auto status = zwave_command_class_user_credential_delete_all_users(endpoint_id_node); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - status, - "Remove all users should have returned SL_STATUS_OK"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Remove all users should have returned SL_STATUS_OK"); TEST_ASSERT_EQUAL_MESSAGE( user_ids.size() @@ -3495,7 +3491,7 @@ void test_user_credential_remove_all_users_happy_case() { 0); TEST_ASSERT_EQUAL_MESSAGE( - 1, // Should be one user left here with desired value of 0 + 1, // Should be one user left here with desired value of 0 attribute_store_get_node_child_count_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID)), "All users should have been removed yet"); @@ -3505,11 +3501,375 @@ void test_user_credential_remove_all_users_happy_case() { = attribute_store_get_node_child_by_value(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), DESIRED_ATTRIBUTE, - (uint8_t*)&user_id, + (uint8_t *)&user_id, sizeof(user_id), 0); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_node), - "Should be one user node with desired value of 0 to perform user interview"); + "Should be one user node with desired value of 0 to " + "perform user interview"); +} + +void test_user_credential_remove_all_credentials_happy_case() +{ + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + std::vector expected_nodes; + // WARNING : All those vectors should be the same size + std::vector user_ids = {12, 12, 12, 15, 19}; + std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + expected_nodes.push_back( + helper_create_credential_structure(user_ids[i], + credential_types[i], + credential_slots[i], + REPORTED_ATTRIBUTE)); + } + + auto status = zwave_command_class_user_credential_delete_all_credentials( + endpoint_id_node); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Remove all credentials should have returned SL_STATUS_OK"); + + std::vector notification_parameters = {0, 0, 0, 0, 0}; + // This will handle the deletion + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x26, // All Credential deleted + // No need to have arguments here + notification_parameters.data(), + notification_parameters.size()); + + for (auto &node: expected_nodes) { + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(node.credential_type_node), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(node.credential_slot_node), + "Credential slot node should have been removed"); + } + + user_credential_user_unique_id_t user_id = 0; + auto user_0_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), + "User 0 should not exists"); +} + +void test_user_credential_remove_all_credentials_of_user() +{ + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_to_delete = 12; + + + std::vector expected_nodes; + // WARNING : All those vectors should be the same size + std::vector user_ids + = {user_to_delete, user_to_delete, user_to_delete, 15, 19}; + std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + expected_nodes.push_back( + helper_create_credential_structure(user_ids[i], + credential_types[i], + credential_slots[i], + REPORTED_ATTRIBUTE)); + } + + auto status + = zwave_command_class_user_credential_delete_all_credentials_for_user( + endpoint_id_node, + user_to_delete); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Remove all credentials for user should have returned SL_STATUS_OK"); + + auto exploded_user_to_delete = explode_uint16(user_to_delete); + std::vector notification_parameters + = {exploded_user_to_delete.msb, exploded_user_to_delete.lsb, 0, 0, 0}; + // This will handle the deletion + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x26, // All Credential deleted + // No need to have arguments here + notification_parameters.data(), + notification_parameters.size()); + + attribute_store_log(); + + for (auto &node: expected_nodes) { + user_credential_user_unique_id_t reported_user_id; + attribute_store_get_reported(node.user_id_node, + &reported_user_id, + sizeof(reported_user_id)); + printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", + node.user_id_node, + node.credential_type_node, + node.credential_slot_node); + + if (reported_user_id == user_to_delete) { + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(node.credential_type_node), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(node.credential_slot_node), + "Credential slot node should have been removed"); + } else { + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(node.credential_type_node), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(node.credential_slot_node), + "Credential slot node should still exist"); + } + } + + user_credential_user_unique_id_t user_id = 0; + auto user_0_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), + "User 0 should not exists"); +} + + +void test_user_credential_remove_all_credentials_of_user_by_type() +{ + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_to_delete = 12; + user_credential_type_t credential_type_to_delete = 1; + + + struct expected_node_data { + credential_structure_nodes nodes; + bool should_not_exist; + }; + std::vector expected_nodes_data; + // WARNING : All those vectors should be the same size + std::vector user_ids + = {user_to_delete, user_to_delete, user_to_delete, 15, 19}; + std::vector credential_types + = {credential_type_to_delete, credential_type_to_delete, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + expected_nodes_data.push_back( + {helper_create_credential_structure(user_ids[i], + credential_types[i], + credential_slots[i], + REPORTED_ATTRIBUTE), + user_ids[i] == user_to_delete + && credential_types[i] == credential_type_to_delete}); + } + + auto status + = zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + endpoint_id_node, + user_to_delete, + credential_type_to_delete); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Remove all credentials for user should have returned SL_STATUS_OK"); + + auto exploded_user_to_delete = explode_uint16(user_to_delete); + std::vector notification_parameters = {exploded_user_to_delete.msb, + exploded_user_to_delete.lsb, + credential_type_to_delete, + 0, + 0}; + + // This will handle the deletion + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x26, // All Credential deleted + // No need to have arguments here + notification_parameters.data(), + notification_parameters.size()); + + attribute_store_log(); + + for (auto &node_data: expected_nodes_data) { + auto nodes = node_data.nodes; + auto should_not_exist = node_data.should_not_exist; + printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", + nodes.user_id_node, + nodes.credential_type_node, + nodes.credential_slot_node); + + if (should_not_exist) { + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(nodes.credential_type_node), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(nodes.credential_slot_node), + "Credential slot node should have been removed"); + } else { + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(nodes.credential_type_node), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(nodes.credential_slot_node), + "Credential slot node should still exist"); + } + } + + user_credential_user_unique_id_t user_id = 0; + auto user_0_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), + "User 0 should not exists"); +} + +void test_user_credential_remove_all_credentials_by_type() +{ + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_type_t credential_type_to_delete = 1; + + + struct expected_node_data { + credential_structure_nodes nodes; + bool should_not_exist; + }; + std::vector expected_nodes_data; + // WARNING : All those vectors should be the same size + std::vector user_ids = {12, 12, 12, 15, 19}; + std::vector credential_types + = {credential_type_to_delete, + credential_type_to_delete, + 2, + 5, + credential_type_to_delete}; + std::vector credential_slots = {1, 2, 2, 1, 3}; + // WARNING : Make sure that all the vector above have the same size + const size_t expected_credential_count = user_ids.size(); + for (size_t i = 0; i < expected_credential_count; i++) { + expected_nodes_data.push_back( + {helper_create_credential_structure(user_ids[i], + credential_types[i], + credential_slots[i], + REPORTED_ATTRIBUTE), + credential_types[i] == credential_type_to_delete}); + } + + auto status + = zwave_command_class_user_credential_delete_all_credentials_by_type( + endpoint_id_node, + credential_type_to_delete); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Remove all credentials for user should have returned SL_STATUS_OK"); + + std::vector notification_parameters + = {0, 0, credential_type_to_delete, 0, 0}; + + // This will handle the deletion + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x26, // All Credential deleted + // No need to have arguments here + notification_parameters.data(), + notification_parameters.size()); + + attribute_store_log(); + + for (auto &node_data: expected_nodes_data) { + auto nodes = node_data.nodes; + auto should_not_exist = node_data.should_not_exist; + printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", + nodes.user_id_node, + nodes.credential_type_node, + nodes.credential_slot_node); + + if (should_not_exist) { + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(nodes.credential_type_node), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(nodes.credential_slot_node), + "Credential slot node should have been removed"); + } else { + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(nodes.credential_type_node), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(nodes.credential_slot_node), + "Credential slot node should still exist"); + } + } + + user_credential_user_unique_id_t user_id = 0; + auto user_0_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + + TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), + "User 0 should not exists"); } } // extern "C" \ No newline at end of file From 3c0886f6343be20833dfe806ff9a35f8342ba738 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 16 May 2024 11:19:55 +0200 Subject: [PATCH 13/60] UIC-3222: Fix User Notification Report Size In the previous implementation of U3C, User Notification Report size was incorrect : https://github.com/Z-Wave-Alliance/z-wave-stack/issues/409 This commit use the correct implementation. --- .../zwave_command_class_user_credential.cpp | 18 ++++++++++-------- ...wave_command_class_user_credential_test.cpp | 5 +---- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 15b542b0b..1612cf33c 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -958,13 +958,13 @@ namespace user { // Indexes // User Notification Report Frame -constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 2; -constexpr uint8_t INDEX_USER_MODIFIER_NODE_ID = 3; -constexpr uint8_t INDEX_USER_UNIQUE_ID = 5; -constexpr uint8_t INDEX_USER_TYPE = 7; -constexpr uint8_t INDEX_USER_ACTIVE_STATE = 8; -constexpr uint8_t INDEX_USER_CREDENTIAL_RULE = 9; -constexpr uint8_t INDEX_USER_EXPIRING_TIMEOUT_MINUTES = 10; +constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 0; +constexpr uint8_t INDEX_USER_MODIFIER_NODE_ID = 1; +constexpr uint8_t INDEX_USER_UNIQUE_ID = 3; +constexpr uint8_t INDEX_USER_TYPE = 5; +constexpr uint8_t INDEX_USER_ACTIVE_STATE = 6; +constexpr uint8_t INDEX_USER_CREDENTIAL_RULE = 7; +constexpr uint8_t INDEX_USER_EXPIRING_TIMEOUT_MINUTES = 8; constexpr uint8_t USER_NOTIFICATION_REPORT_FRAME_LENGTH = INDEX_USER_EXPIRING_TIMEOUT_MINUTES + 2; @@ -1051,7 +1051,9 @@ void update_user_reported_values(attribute_store_node_t user_id_node, bool is_report_size_conform(uint8_t event_parameters_length) { if (event_parameters_length != USER_NOTIFICATION_REPORT_FRAME_LENGTH) { - sl_log_error(LOG_TAG, "Invalid User Notification Report size"); + sl_log_error(LOG_TAG, "Invalid User Notification Report size got %d, expected %d", + event_parameters_length, + USER_NOTIFICATION_REPORT_FRAME_LENGTH); return false; } return true; diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 7db84ad2b..61c4c48a4 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1127,10 +1127,7 @@ std::vector helper_create_user_notification_report( user_credential_supported_credential_rules_t credential_rule, user_credential_expiring_timeout_minutes_t expiring_timeout_minutes) { - // FIXME: This will be changed - // https://github.com/Z-Wave-Alliance/z-wave-stack/issues/409 - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, USER_NOTIFICATION_REPORT}; + std::vector report_frame; report_frame.push_back(user_modifier_type); From c0eb783fc15295fb13db0ab04d1aa0bb21af63be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 21 May 2024 14:55:23 +0200 Subject: [PATCH 14/60] UIC-3222: Enforce uniqueness of Credential Type, Credential Slot pair This commit will ensure that no more than Credential Type/Credential Slot exists no matter the user that got it. If we have (1,1) credential for User 1, user 2 cannot have a credential with type 1 and slot 1. User 2 should have type 1 and slot 2. For more context see https://github.com/Z-Wave-Alliance/AWG/issues/172 --- .../zwave_command_class_user_credential.cpp | 26 +++- ...ave_command_class_user_credential_test.cpp | 124 ++++++++++++++++-- 2 files changed, 138 insertions(+), 12 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 1612cf33c..3db246a6f 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -3326,6 +3326,30 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + auto credential_type_nodes + = get_all_credential_type_nodes(endpoint_node, credential_type); + + // Credential type, Credential Node pair is Unique + for (auto &credential_type_node : credential_type_nodes) { + user_credential_type_t current_type; + attribute_store_get_reported(credential_type_node, + ¤t_type, + sizeof(current_type)); + user_credential_slot_t current_slot; + attribute_store_get_child_reported(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + ¤t_slot, + sizeof(current_slot)); + if (current_slot == credential_slot && current_type == credential_type) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + } + // First check Credential Type existance get_credential_type_node(endpoint_node, user_id, @@ -3338,7 +3362,7 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( REPORTED_ATTRIBUTE, credential_slot_node); - // If a Credential Slot already exists we can't add a ne w one + // If a Credential Slot already exists we can't add a new one if (attribute_store_node_exists(credential_slot_node)) { sl_log_error(LOG_TAG, "Credential slot %d for Credential Type %d already exists. " diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 61c4c48a4..13f9ee55e 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2309,6 +2309,112 @@ void test_user_credential_notification_empty_parameters() } } +void test_user_credential_add_credential_already_defined_cred_type_and_slot() +{ + // Initialize the notification callback + const zwave_cc_version_t version = 1; + attribute_store_set_child_reported(endpoint_id_node, + ATTRIBUTE(VERSION), + &version, + sizeof(version)); + + TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, + "Notification callback should be defined"); + + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + std::string credential_data = "12"; + bool crb = true; + user_credential_modifier_type_t credential_modifier_type = 2; + user_credential_modifier_node_id_t credential_modifier_node_id = 1212; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); + + // Add credential + sl_status_t status = zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + credential_data.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Credential add should have returned SL_STATUS_OK"); + + // Simulate notification so that the credential is marked as reported + auto credential_notification_report + = helper_create_credential_notification_report(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id); + + // Endpoint send User Add notification + notification_callback(endpoint_id_node, + NOTIFICATION_ACCESS_CONTROL, + 0x2B, // Credential added + credential_notification_report.data(), + credential_notification_report.size()); + + // Try to add same credential type and slot on same user but with different credential data + credential_data = "1234"; + status = zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + credential_data.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + status, + "Credential add should have returned SL_STATUS_FAIL (trying to add same credential type/slot to same user)."); + + // Try to add same credential type/slot on other user + user_id = 15; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + status = zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + credential_data.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + status, + "Credential add should have returned SL_STATUS_FAIL (trying to add same credential type/slot to different user)."); +} + void test_user_credential_user_notification_add_modify_delete_happy_case() { // Initialize the notification callback @@ -3585,13 +3691,12 @@ void test_user_credential_remove_all_credentials_of_user() user_credential_user_unique_id_t user_to_delete = 12; - std::vector expected_nodes; // WARNING : All those vectors should be the same size std::vector user_ids = {user_to_delete, user_to_delete, user_to_delete, 15, 19}; - std::vector credential_types = {1, 1, 2, 5, 1}; - std::vector credential_slots = {1, 2, 2, 1, 3}; + std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { @@ -3665,7 +3770,6 @@ void test_user_credential_remove_all_credentials_of_user() "User 0 should not exists"); } - void test_user_credential_remove_all_credentials_of_user_by_type() { const zwave_cc_version_t version = 1; @@ -3677,10 +3781,9 @@ void test_user_credential_remove_all_credentials_of_user_by_type() TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); - user_credential_user_unique_id_t user_to_delete = 12; + user_credential_user_unique_id_t user_to_delete = 12; user_credential_type_t credential_type_to_delete = 1; - struct expected_node_data { credential_structure_nodes nodes; bool should_not_exist; @@ -3691,7 +3794,7 @@ void test_user_credential_remove_all_credentials_of_user_by_type() = {user_to_delete, user_to_delete, user_to_delete, 15, 19}; std::vector credential_types = {credential_type_to_delete, credential_type_to_delete, 2, 5, 1}; - std::vector credential_slots = {1, 2, 2, 1, 3}; + std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { @@ -3715,7 +3818,7 @@ void test_user_credential_remove_all_credentials_of_user_by_type() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - auto exploded_user_to_delete = explode_uint16(user_to_delete); + auto exploded_user_to_delete = explode_uint16(user_to_delete); std::vector notification_parameters = {exploded_user_to_delete.msb, exploded_user_to_delete.lsb, credential_type_to_delete, @@ -3733,7 +3836,7 @@ void test_user_credential_remove_all_credentials_of_user_by_type() attribute_store_log(); for (auto &node_data: expected_nodes_data) { - auto nodes = node_data.nodes; + auto nodes = node_data.nodes; auto should_not_exist = node_data.should_not_exist; printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", nodes.user_id_node, @@ -3783,7 +3886,6 @@ void test_user_credential_remove_all_credentials_by_type() user_credential_type_t credential_type_to_delete = 1; - struct expected_node_data { credential_structure_nodes nodes; bool should_not_exist; @@ -3833,7 +3935,7 @@ void test_user_credential_remove_all_credentials_by_type() attribute_store_log(); for (auto &node_data: expected_nodes_data) { - auto nodes = node_data.nodes; + auto nodes = node_data.nodes; auto should_not_exist = node_data.should_not_exist; printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", nodes.user_id_node, From e778f0c60c5ca21c067b8376f030d6e185d494f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 28 May 2024 17:06:02 +0200 Subject: [PATCH 15/60] UIC-3222: Credential Learn Start/Stop --- .../src/user_credential_cluster_server.cpp | 96 +- .../user_credential_cluster_server_test.cpp | 401 ++++-- .../attribute_store_defined_attribute_types.h | 12 + ...wave_command_class_user_credential_types.h | 6 + .../zpc_attribute_store_type_registration.cpp | 6 + .../zwave_command_class_user_credential.cpp | 1166 +++++++++++++---- .../src/zwave_command_class_user_credential.h | 54 + ...ave_command_class_user_credential_test.cpp | 604 ++++++++- 8 files changed, 1964 insertions(+), 381 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index d4003d7d6..6161b4272 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -424,6 +424,91 @@ static sl_status_t delete_all_credentials_for_user_by_type( static_cast(credential_type)); } +sl_status_t credential_learn_start_add( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + uint8_t credential_learn_timeout) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_credential_learn_start_add( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + credential_slot, + credential_learn_timeout); +} + +sl_status_t credential_learn_start_modify( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + uint8_t credential_learn_timeout) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_credential_learn_start_modify( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + credential_slot, + credential_learn_timeout); +} + + +sl_status_t credential_learn_stop( + dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_credential_learn_stop( + endpoint_node); +} /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -842,6 +927,15 @@ sl_status_t user_credential_cluster_server_init() &delete_all_credentials_for_user); uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set( &delete_all_credentials_for_user_by_type); + // Credential Learn + uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set( + &credential_learn_start_add); + uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set( + &credential_learn_start_modify); + uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set( + &credential_learn_stop); + return SL_STATUS_OK; -} \ No newline at end of file +} + diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index a466cd019..e98cd917e 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -31,6 +31,7 @@ extern "C" { // Test helpers #include "zpc_attribute_store_test_helper.h" +#include "sl_log.h" // Unify components #include "datastore.h" @@ -55,7 +56,6 @@ void mock_deletion_cred_rule_mqtt_topic(user_credential_type_t credential_type); void setup_user_capabilities(); void setup_cred_capabilities(); - // Keep a reference to the mqtt topics we want to test // Stored as static std::vector> mqtt_topics; @@ -64,8 +64,7 @@ static std::vector> created_credential_ids; -static std::vector - created_supported_credential_types; +static std::vector created_supported_credential_types; // Callback functions // clang-format off @@ -80,6 +79,9 @@ uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t delete_all_cre uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t delete_all_credentials_by_type_command = NULL; uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t delete_all_credentials_for_user_command = NULL; uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t delete_all_credentials_for_user_by_type_command = NULL; +uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t credential_learn_start_add_command = NULL; +uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t credential_learn_start_modify_command = NULL; +uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t credential_learn_stop_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -129,30 +131,57 @@ void uic_mqtt_dotdot_user_credential_delete_all_users_callback_set_stub( delete_all_users_command = callback; } void uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_set_stub( - const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t callback, + const uic_mqtt_dotdot_user_credential_delete_all_credentials_callback_t + callback, int cmock_num_calls) { delete_all_credentials_command = callback; } void uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub( - const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t callback, + const uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_t + callback, int cmock_num_calls) { delete_all_credentials_by_type_command = callback; } void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub( - const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t callback, + const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_t + callback, int cmock_num_calls) { delete_all_credentials_for_user_command = callback; } void uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub( - const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t callback, + const uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_t + callback, int cmock_num_calls) { delete_all_credentials_for_user_by_type_command = callback; } +void uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_stub( + const uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t + callback, + int cmock_num_calls) +{ + credential_learn_start_add_command = callback; +} + +void uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_stub( + const uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t + callback, + int cmock_num_calls) +{ + credential_learn_start_modify_command = callback; +} + +void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub( + const uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t + callback, + int cmock_num_calls) +{ + credential_learn_stop_command = callback; +} /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() @@ -174,9 +203,19 @@ int suiteTearDown(int num_failures) /// Called before each and every test void setUp() { + sl_log_set_level(sl_log_level::SL_LOG_INFO); + + // If you can to enable MQTT topics logs : + // sl_log_set_tag_level("user_credential_cluster_server", + // sl_log_level::SL_LOG_DEBUG); + + sl_log_set_tag_level("zwave_command_class_user_credential", + sl_log_level::SL_LOG_DEBUG); + sl_log_set_tag_level("attribute_store", sl_log_level::SL_LOG_DEBUG); + // WARNING : Order matters here - // Check if credential rules need to be removed - for(auto cred_type: created_supported_credential_types) { + // Check if credential rules need to be removed + for (auto cred_type: created_supported_credential_types) { mock_deletion_cred_rule_mqtt_topic(cred_type); } // Check if any users that need to be removed @@ -190,8 +229,6 @@ void setUp() std::get<2>(cred_id)); } - - zpc_attribute_store_test_helper_create_network(); // Intercept the dotdot MQTT callbacks @@ -219,12 +256,16 @@ void setUp() uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_by_type_callback_set_stub); uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_callback_set_stub); uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_Stub(&uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback_set_stub); + // Credential learn + uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_stub); + uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_stub); + uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub); // clang-format on // Run the component init TEST_ASSERT_EQUAL(SL_STATUS_OK, user_credential_cluster_server_init()); - // We are not here to test user capabilities, so we need to set them up to + // We are not here to test user capabilities, so we need to set them up to // accept our test data setup_user_capabilities(); // Need to call this after init() to have the mqtt callback initialized @@ -234,18 +275,15 @@ void setUp() ///////////////////////////////////////////////////////////////////////// // Mqtt topics helpers ///////////////////////////////////////////////////////////////////////// -std::string get_base_topic(bool include_user=true) +std::string get_base_topic(bool include_user = true) { const std::string user_str = include_user ? "/User" : ""; - const std::string base - = "ucl/by-unid/%1%/ep%2%/UserCredential/Attributes%3%"; - return (boost::format(base) % supporting_node_unid - % (unsigned int)endpoint_id % user_str) + const std::string base = "ucl/by-unid/%1%/ep%2%/UserCredential/Attributes%3%"; + return (boost::format(base) % supporting_node_unid % (unsigned int)endpoint_id + % user_str) .str(); } - - std::string get_user_attribute_mqtt_topic(user_credential_user_unique_id_t user_unique_id, const std::string &attribute_name) @@ -269,14 +307,12 @@ std::string .str(); } -std::string - get_cred_rule_mqtt_topic(user_credential_type_t credential_type, - const std::string &attribute_name) +std::string get_cred_rule_mqtt_topic(user_credential_type_t credential_type, + const std::string &attribute_name) { const std::string base = "%1%/Credentials/%2%/%3%/Reported"; return (boost::format(base) % get_base_topic(false) - % cred_type_get_enum_value_name(credential_type) - % attribute_name) + % cred_type_get_enum_value_name(credential_type) % attribute_name) .str(); } @@ -366,9 +402,8 @@ void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, user_credential_slot_t credential_slot) { // WARNING : Order here matters based on their initialization order in the add_complete_credential function - std::vector attribute_names = {"CredentialData", - "CredentialModifierNodeId", - "CredentialModifierType"}; + std::vector attribute_names + = {"CredentialData", "CredentialModifierNodeId", "CredentialModifierType"}; for (auto &attribute_name: attribute_names) { mqtt_topics.push_back({get_cred_attribute_mqtt_topic(user_id, credential_type, @@ -403,13 +438,14 @@ void mock_deletion_cred_rule_mqtt_topic(user_credential_type_t credential_type) ///////////////////////////////////////////////////////////////////////// // Capabilities Helper ///////////////////////////////////////////////////////////////////////// -void setup_user_capabilities() { - uint16_t number_of_users = 12; +void setup_user_capabilities() +{ + uint16_t number_of_users = 12; user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; - uint8_t username_max_length = 112; - uint8_t support_user_schedule = 0; - uint8_t support_all_users_checksum = 0; - uint8_t support_user_checksum = 0; + uint8_t username_max_length = 112; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum = 0; + uint8_t support_user_checksum = 0; user_credential_supported_user_type_bitmask_t supported_user_types_bitmask = 0xFF; @@ -449,26 +485,25 @@ void setup_user_capabilities() { sizeof(supported_user_types_bitmask)); } -void setup_cred_capabilities() { - +void setup_cred_capabilities() +{ // Supports ZCL_CRED_TYPE_PIN_CODE..ZCL_CRED_TYPE_UWB // Adjust if needed, we don't need to test all types and this outputs a lot of noise on the logs uint8_t max_cred_type = ZCL_CRED_TYPE_UWB; - for (uint8_t i=ZCL_CRED_TYPE_PIN_CODE;i<=max_cred_type;i++) { - user_credential_type_t cred_type - = static_cast(i); + for (uint8_t i = ZCL_CRED_TYPE_PIN_CODE; i <= max_cred_type; i++) { + user_credential_type_t cred_type = static_cast(i); auto supported_cred_type_node = attribute_store_emplace(endpoint_id_node, ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), &cred_type, sizeof(cred_type)); - uint8_t crb_support = 1; - uint16_t slot_supported = 0xFFFF; + uint8_t crb_support = 1; + uint16_t slot_supported = 0xFFFF; uint16_t cred_min_length = 0; uint16_t cred_max_length = 0xFF; - uint8_t learn_timeout = 112; - uint8_t learn_steps = 12; + uint8_t learn_timeout = 112; + uint8_t learn_steps = 12; mock_expected_cred_rule_mqtt_topic(cred_type, "LearnSupport", @@ -519,7 +554,6 @@ void setup_cred_capabilities() { &learn_steps, sizeof(learn_steps)); - // Will allow to test deletion of attributes created_supported_credential_types.push_back(cred_type); } @@ -531,12 +565,16 @@ void setup_cred_capabilities() { extern "C" { void helper_test_operation_type(attribute_store_node_t parent_node, - user_credential_operation_type_t operation_type) + user_credential_operation_type_t operation_type, + attribute_store_type_t tested_attribute_type = 0) { - attribute_store_type_t tested_attribute_type = ATTRIBUTE(USER_OPERATION_TYPE); - // If we are testing a credential we test its attribute instead - if (attribute_store_get_node_type(parent_node) != ATTRIBUTE(USER_UNIQUE_ID)) { - tested_attribute_type = ATTRIBUTE(CREDENTIAL_OPERATION_TYPE); + if (tested_attribute_type == 0) { + tested_attribute_type = ATTRIBUTE(USER_OPERATION_TYPE); + // If we are testing a credential we test its attribute instead + if (attribute_store_get_node_type(parent_node) + != ATTRIBUTE(USER_UNIQUE_ID)) { + tested_attribute_type = ATTRIBUTE(CREDENTIAL_OPERATION_TYPE); + } } attribute_store_node_t operation_type_node = attribute_store_get_first_child_by_type(parent_node, @@ -604,7 +642,6 @@ attribute_store_node_t helper_add_complete_user( &expiring_timeout, sizeof(expiring_timeout)); - mock_expected_user_mqtt_topic( user_id, "UserNameEncoding", @@ -623,7 +660,8 @@ attribute_store_node_t helper_add_complete_user( // Reported attributes by the end device // Need those to test MQTT topics user_credential_modifier_node_id_t modifier_node_id = 1212; - user_credential_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_LOCALLY; + user_credential_modifier_type_t modifier_type + = ZCL_USER_MODIFIER_TYPE_LOCALLY; mock_expected_user_mqtt_topic(user_id, "UserModifierNodeId", static_cast(modifier_node_id)); @@ -631,9 +669,10 @@ attribute_store_node_t helper_add_complete_user( ATTRIBUTE(USER_MODIFIER_NODE_ID), &modifier_node_id, sizeof(modifier_node_id)); - mock_expected_user_mqtt_topic(user_id, - "UserModifierType", - user_modifier_type_get_enum_value_name(modifier_type)); + mock_expected_user_mqtt_topic( + user_id, + "UserModifierType", + user_modifier_type_get_enum_value_name(modifier_type)); attribute_store_emplace(user_id_node, ATTRIBUTE(USER_MODIFIER_TYPE), &modifier_type, @@ -716,11 +755,12 @@ attribute_store_node_t ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), &modifier_node_id, sizeof(modifier_node_id)); - mock_expected_cred_mqtt_topic(user_id, - credential_type, - credential_slot, - "CredentialModifierType", - user_modifier_type_get_enum_value_name(modifier_type)); + mock_expected_cred_mqtt_topic( + user_id, + credential_type, + credential_slot, + "CredentialModifierType", + user_modifier_type_get_enum_value_name(modifier_type)); attribute_store_emplace(credential_slot_node, ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), &modifier_type, @@ -1333,9 +1373,9 @@ void test_user_credential_cluster_add_credential_others_happy_case() { // Simulate user user_credential_user_unique_id_t user_unique_id = 12; - CredType credential_type = CredType::ZCL_CRED_TYPE_RFID_CODE; - user_credential_slot_t credential_slot = 1; - const char *credential_data = "hunter2"; + CredType credential_type = CredType::ZCL_CRED_TYPE_RFID_CODE; + user_credential_slot_t credential_slot = 1; + const char *credential_data = "hunter2"; // Add simple user helper_add_user_id(user_unique_id); @@ -1651,22 +1691,22 @@ void test_user_credential_cluster_delete_all_users_happy_case() TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, delete_all_users_command(supporting_node_unid, - endpoint_id, - UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), "Should be able to setup attribute store for all user deletion"); - - user_unique_id = 0; - auto deletion_user_node + user_unique_id = 0; + auto deletion_user_node = attribute_store_get_node_child_by_value(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), REPORTED_ATTRIBUTE, - (uint8_t*)&user_unique_id, + (uint8_t *)&user_unique_id, sizeof(user_unique_id), 0); TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(deletion_user_node), - "Should be one user node with desired value of 0 to perform user interview"); + "Should be one user node with desired value of 0 to " + "perform user interview"); helper_test_operation_type(deletion_user_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); } @@ -1674,20 +1714,20 @@ void test_user_credential_cluster_delete_all_users_happy_case() void test_user_credential_cluster_delete_all_credential_happy_case() { user_credential_user_unique_id_t user_unique_id = 0; - user_credential_type_t credential_type = 0; - user_credential_slot_t credential_slot = 0; + user_credential_type_t credential_type = 0; + user_credential_slot_t credential_slot = 0; std::vector user_ids = {12, 12, 12, 15, 19}; std::vector credential_types = {1, 1, 2, 5, 1}; - std::vector credential_slots = {1, 2, 2, 1, 3}; - + std::vector credential_slots = {1, 2, 2, 1, 3}; + // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { helper_add_complete_credential(user_ids[i], - credential_types[i], - credential_slots[i], - "1"); + credential_types[i], + credential_slots[i], + "1"); } TEST_ASSERT_EQUAL_MESSAGE( @@ -1697,7 +1737,6 @@ void test_user_credential_cluster_delete_all_credential_happy_case() UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), "Should be able to setup attribute store for all credential deletion"); - auto deletion_user_node = attribute_store_get_node_child_by_value(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), @@ -1732,34 +1771,33 @@ void test_user_credential_cluster_delete_all_credential_happy_case() void test_user_credential_cluster_delete_all_credential_for_user_happy_case() { - user_credential_user_unique_id_t user_unique_id = 12; - user_credential_type_t credential_type = 0; - user_credential_slot_t credential_slot = 0; + user_credential_type_t credential_type = 0; + user_credential_slot_t credential_slot = 0; std::vector user_ids = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; - std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_types = {1, 1, 2, 5, 1}; std::vector credential_slots = {1, 2, 2, 1, 3}; - + // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { helper_add_complete_credential(user_ids[i], - credential_types[i], - credential_slots[i], - "1"); + credential_types[i], + credential_slots[i], + "1"); } TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - delete_all_credentials_for_user_command(supporting_node_unid, - endpoint_id, - UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, - user_unique_id), + delete_all_credentials_for_user_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id), "Should be able to setup attribute store for all credential deletion"); - auto deletion_user_node = attribute_store_get_node_child_by_value(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), @@ -1794,24 +1832,23 @@ void test_user_credential_cluster_delete_all_credential_for_user_happy_case() void test_user_credential_cluster_delete_all_credential_for_user_by_type_happy_case() { - user_credential_user_unique_id_t user_unique_id = 12; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 0; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 0; std::vector user_ids = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; std::vector credential_types = {credential_type, credential_type, 2, 5, credential_type}; std::vector credential_slots = {1, 2, 2, 1, 3}; - + // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { helper_add_complete_credential(user_ids[i], - credential_types[i], - credential_slots[i], - "1"); + credential_types[i], + credential_slots[i], + "1"); } TEST_ASSERT_EQUAL_MESSAGE( @@ -1858,32 +1895,31 @@ void test_user_credential_cluster_delete_all_credential_for_user_by_type_happy_c void test_user_credential_cluster_delete_all_credential_by_type_happy_case() { - user_credential_user_unique_id_t user_unique_id = 0; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 0; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 0; - std::vector user_ids - = {12, 12, 12, 15, 19}; + std::vector user_ids = {12, 12, 12, 15, 19}; std::vector credential_types = {credential_type, credential_type, 2, 5, credential_type}; std::vector credential_slots = {1, 2, 2, 1, 3}; - + // WARNING : Make sure that all the vector above have the same size const size_t expected_credential_count = user_ids.size(); for (size_t i = 0; i < expected_credential_count; i++) { helper_add_complete_credential(user_ids[i], - credential_types[i], - credential_slots[i], - "1"); + credential_types[i], + credential_slots[i], + "1"); } TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, - delete_all_credentials_by_type_command(supporting_node_unid, - endpoint_id, - UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, - static_cast(credential_type)), + delete_all_credentials_by_type_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + static_cast(credential_type)), "Should be able to setup attribute store for all credential deletion"); auto deletion_user_node @@ -1918,6 +1954,151 @@ void test_user_credential_cluster_delete_all_credential_by_type_happy_case() USER_CREDENTIAL_OPERATION_TYPE_DELETE); } +/////////////////////////////////////////////////// +// Learn Start +/////////////////////////////////////////////////// +void test_user_credential_cluster_learn_start_add_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t expected_timeout = 30; + + helper_add_user_id(user_unique_id); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + credential_learn_start_add_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + static_cast(credential_type), + credential_slot, + expected_timeout), + "Should be able to setup attribute store for learn start"); + + auto user_id_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto credential_type_node + = attribute_store_get_node_child_by_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + DESIRED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto credential_slot_node + = attribute_store_get_node_child_by_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + "User node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential slot should exists"); + + helper_test_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)); + user_credential_learn_timeout_t timeout = 0; + attribute_store_get_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + &timeout, + sizeof(timeout)); + TEST_ASSERT_EQUAL_MESSAGE(expected_timeout, + timeout, + "Timeout value mismatch"); +} + +void test_user_credential_cluster_learn_start_modify_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t expected_timeout = 30; + + helper_add_user_id(user_unique_id); + helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + "1234"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + credential_learn_start_modify_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id, + static_cast(credential_type), + credential_slot, + expected_timeout), + "Should be able to setup attribute store for learn start"); + + auto user_id_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_unique_id, + sizeof(user_unique_id), + 0); + auto credential_type_node + = attribute_store_get_node_child_by_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto credential_slot_node + = attribute_store_get_node_child_by_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + "User node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential slot should exists"); + + helper_test_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)); + uint8_t timeout = 0; + attribute_store_get_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + &timeout, + sizeof(timeout)); + TEST_ASSERT_EQUAL_MESSAGE(expected_timeout, + timeout, + "Timeout value mismatch"); +} + +void test_user_credential_cluster_learn_stop_happy_case() +{ + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + credential_learn_stop_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + "Should be able to setup attribute store for learn stop"); + + uint8_t stop_flag = 0; + auto stop_node + = attribute_store_get_node_child_by_type(endpoint_id_node, + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + 0); + attribute_store_get_desired(stop_node, &stop_flag, sizeof(stop_flag)); + TEST_ASSERT_EQUAL_MESSAGE(1, stop_flag, "Stop flag should be set to 1"); +} /////////////////////////////////////////////////// // Support tests @@ -1985,7 +2166,7 @@ void test_user_credential_cluster_test_user_command_not_supported_happy_case() // We don't want anything in the tree for this test // This way we can make support check fails // We need to inform the MQTT of the deleted credential type rules - for(auto cred_type: created_supported_credential_types) { + for (auto cred_type: created_supported_credential_types) { mock_deletion_cred_rule_mqtt_topic(cred_type); } // Delete all the nodes diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index b79c8926b..3e5bba6dc 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1205,6 +1205,18 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) +// Specific to Credential Learn +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_OPERATION_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x24)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) + DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) + ///////////////////////////////////////////////// // Z-Wave Plus Info CC DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_ZWAVEPLUS_INFO_VERSION, diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index 8ec3d4e2f..7d9381bef 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -73,6 +73,12 @@ typedef uint8_t user_credential_operation_type_t; ///> Expiring Timeout for User (Minutes). uint16_t typedef uint16_t user_credential_expiring_timeout_minutes_t; +///> Expiring Timeout for Credential Learn (Seconds). uint8_t +typedef uint8_t user_credential_learn_timeout_t; + +///> Credential Learn Status. uint8_t +typedef uint8_t user_credential_learn_status_t; + #ifdef __cplusplus extern "C" { #endif diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index ec1772be6..a64f0bcca 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -504,6 +504,12 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, "User Credential Credential Read Back Flag", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, "User Credential Credential Modifier type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, "User Credential Credential Node ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_OPERATION_TYPE, "User Credential Credential Learn Operation Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, "User Credential Credential Learn Timeout", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, "User Credential Credential Learn Status", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, "User Credential Credential Learn Steps Remaining", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + // Only one learn can be active at the time, so we make this attribute on the endpoint node + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, "User Credential Credential Learn Stop Flag", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, ///////////////////////////////////////////////////////////////////// // Z-Wave Plus Info Command Class attributes diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 3db246a6f..56e08dbee 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -125,7 +125,7 @@ struct user_capabilities { // Device support for getting the checksum of all users uint8_t support_all_user_checksum = 0; // Device support for getting the checksum of a specific user - uint8_t support_by_user_checksum = 0 ; + uint8_t support_by_user_checksum = 0; // True if the data is valid inside this struct bool is_data_valid = false; @@ -183,7 +183,7 @@ struct user_capabilities { * @return true User name is valid * @return false User name is not valid */ - bool is_user_name_valid(const char* user_name) const + bool is_user_name_valid(const char *user_name) const { std::string str_user_name(user_name); return str_user_name.length() <= max_user_name_length; @@ -216,30 +216,34 @@ struct user_capabilities { * @return true Credential rule is supported * @return false Credential rule is not supported */ - bool is_credential_rule_supported(user_credential_rule_t credential_rule) const + bool + is_credential_rule_supported(user_credential_rule_t credential_rule) const { return (supported_credential_rules_bitmask & (1 << credential_rule)); } }; - // Associated with a Credential type struct credential_capabilities { user_credential_type_t credential_type = 0; - uint16_t max_slot_count = 0; - uint8_t learn_support = 0; - uint16_t min_credential_length = 0; - uint16_t max_credential_length = 0; - uint8_t learn_recommended_timeout = 0; - uint8_t learn_number_of_steps = 0; + uint16_t max_slot_count = 0; + uint8_t learn_support = 0; + uint16_t min_credential_length = 0; + uint16_t max_credential_length = 0; + uint8_t learn_recommended_timeout = 0; + uint8_t learn_number_of_steps = 0; bool is_data_valid = false; + bool is_learn_supported() const + { + return is_data_valid && learn_support > 0; + } + bool is_credential_valid(user_credential_type_t credential_type, user_credential_slot_t credential_slot, const std::vector &credential_data) { - if (!is_data_valid) { sl_log_error( LOG_TAG, @@ -262,7 +266,9 @@ struct credential_capabilities { } if (!is_credential_data_valid(credential_data)) { - sl_log_error(LOG_TAG, "Credential data size is not valid. Should be between %d and %d, given : %d", + sl_log_error(LOG_TAG, + "Credential data size is not valid. Should be between %d " + "and %d, given : %d", min_credential_length, max_credential_length, credential_data.size()); @@ -277,7 +283,8 @@ struct credential_capabilities { return credential_slot <= max_slot_count; } - bool is_credential_data_valid(const std::vector &credential_data) const + bool + is_credential_data_valid(const std::vector &credential_data) const { return (credential_data.size() >= min_credential_length && credential_data.size() <= max_credential_length); @@ -327,7 +334,7 @@ sl_status_t get_attributes(attribute_store_node_t parent_node, if (status != SL_STATUS_OK) { sl_log_error(LOG_TAG, "Can't get value for attribute %s", - attribute_store_get_type_name(attribute.first)); + attribute_store_get_type_name(attribute.first)); } status |= current_status; @@ -346,18 +353,20 @@ user_capabilities get_user_capabilities(attribute_store_node_t endpoint_node) { user_capabilities capabilities; - std::map attributes = { + std::map attributes = { {ATTRIBUTE(NUMBER_OF_USERS), &capabilities.max_user_count}, - {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), &capabilities.supported_credential_rules_bitmask}, - {ATTRIBUTE(SUPPORTED_USER_TYPES), &capabilities.supported_user_types_bitmask}, + {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), + &capabilities.supported_credential_rules_bitmask}, + {ATTRIBUTE(SUPPORTED_USER_TYPES), + &capabilities.supported_user_types_bitmask}, {ATTRIBUTE(MAX_USERNAME_LENGTH), &capabilities.max_user_name_length}, {ATTRIBUTE(SUPPORT_USER_SCHEDULE), &capabilities.support_user_schedule}, - {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), &capabilities.support_all_user_checksum}, - {ATTRIBUTE(SUPPORT_USER_CHECKSUM), &capabilities.support_by_user_checksum} - }; + {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), + &capabilities.support_all_user_checksum}, + {ATTRIBUTE(SUPPORT_USER_CHECKSUM), &capabilities.support_by_user_checksum}}; sl_status_t status = get_attributes(endpoint_node, attributes); - + capabilities.is_data_valid = (status == SL_STATUS_OK); return capabilities; @@ -387,22 +396,26 @@ credential_capabilities 0); if (!attribute_store_node_exists(supported_credential_type_node)) { - sl_log_error(LOG_TAG, "Credential type %d not supported. Can't get capabilities", credential_type); + sl_log_error(LOG_TAG, + "Credential type %d not supported. Can't get capabilities", + credential_type); return capabilities; } - std::map attributes = { + std::map attributes = { {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), &capabilities.max_slot_count}, {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), &capabilities.learn_support}, {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), &capabilities.min_credential_length}, {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), &capabilities.max_credential_length}, - {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), &capabilities.learn_recommended_timeout}, - {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), &capabilities.learn_number_of_steps} - }; - - sl_status_t status = get_attributes(supported_credential_type_node, attributes); + {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + &capabilities.learn_recommended_timeout}, + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), + &capabilities.learn_number_of_steps}}; + + sl_status_t status + = get_attributes(supported_credential_type_node, attributes); capabilities.credential_type = credential_type; - capabilities.is_data_valid = (status == SL_STATUS_OK); + capabilities.is_data_valid = (status == SL_STATUS_OK); return capabilities; } @@ -494,6 +507,15 @@ void set_credential_operation_type( operation_type); } +void set_credential_learn_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + operation_type); +} + /** * @brief Get user id node * @@ -608,7 +630,7 @@ bool get_credential_type_node(attribute_store_node_t endpoint_node, */ std::vector get_all_credential_type_nodes(attribute_store_node_t endpoint_node, - user_credential_type_t credential_type = 0) + user_credential_type_t credential_type = 0) { std::vector credential_type_nodes; @@ -685,6 +707,84 @@ bool get_credential_slot_node(attribute_store_node_t credential_type_node, return attribute_store_node_exists(credential_slot_node); } +/** + * @brief Checks if given credential ID (credential type, credential slot) is available + * + * @param endpoint_node Endpoint node + * @param credential_type Credential type + * @param credential_slot Credential slot + * + * @return true Credential is available + * @return false Credential is not available : if an user already have the combination of given credential type and slot. +*/ +bool is_credential_available(attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + auto credential_type_nodes + = get_all_credential_type_nodes(endpoint_node, credential_type); + + // Credential type, Credential Node pair is Unique + for (auto &credential_type_node: credential_type_nodes) { + user_credential_type_t current_type; + attribute_store_get_reported(credential_type_node, + ¤t_type, + sizeof(current_type)); + user_credential_slot_t current_slot; + attribute_store_get_child_reported(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + ¤t_slot, + sizeof(current_slot)); + if (current_slot == credential_slot && current_type == credential_type) { + return false; + } + } + + return true; +} + +/** + * @brief Add credential type node to given user if it doesn't exists. + * + * @param endpoint_node Endpoint node + * @param user_id User ID. Must exists. + * @param credential_type Credential type + * + * @return attribute_store_node_t Credential type node (with desired value if it doesn't exists, or the existant one) + * @return ATTRIBUTE_STORE_INVALID_NODE If an error occurred + **/ +attribute_store_node_t + add_credential_type_node_if_missing(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type) +{ + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, "User ID %d doesn't exists", user_id); + return credential_type_node; + } + + // First check Credential Type existence + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + if (!attribute_store_node_exists(credential_type_node)) { + // Create Credential Type if it doesn't exists + credential_type_node + = attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + } + + return credential_type_node; +} ///////////////////////////////////////////////////////////////////////////// // Attributes helpers ///////////////////////////////////////////////////////////////////////////// @@ -1051,9 +1151,10 @@ void update_user_reported_values(attribute_store_node_t user_id_node, bool is_report_size_conform(uint8_t event_parameters_length) { if (event_parameters_length != USER_NOTIFICATION_REPORT_FRAME_LENGTH) { - sl_log_error(LOG_TAG, "Invalid User Notification Report size got %d, expected %d", + sl_log_error(LOG_TAG, + "Invalid User Notification Report size got %d, expected %d", event_parameters_length, - USER_NOTIFICATION_REPORT_FRAME_LENGTH); + USER_NOTIFICATION_REPORT_FRAME_LENGTH); return false; } return true; @@ -1087,10 +1188,11 @@ user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) { return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); } -user_credential_modifier_type_t get_credential_modifier_type(const uint8_t *event_parameters) +user_credential_modifier_type_t + get_credential_modifier_type(const uint8_t *event_parameters) { - // TODO : Update this with the new specification where CREDENTIAL_DATA doesn't exists anymore - return event_parameters[8]; + // TODO : Update this with the new specification where CREDENTIAL_DATA doesn't exists anymore + return event_parameters[8]; } attribute_store_node_t @@ -1538,8 +1640,8 @@ void on_notification_event(attribute_store_node_t endpoint_node, credential_slot, user_id); } break; - // Credential unchanged - case 0x2E: { + // Credential unchanged + case 0x2E: { sl_log_debug(LOG_TAG, "Notification : Credential Unchanged"); if (!notification_handler::credential::is_report_size_conform( event_parameters_length)) { @@ -1561,10 +1663,11 @@ void on_notification_event(attribute_store_node_t endpoint_node, if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { return; } - + // If user doesn't exists in the device we try to remove it also from our side user_credential_modifier_type_t modifier_type - = notification_handler::credential::get_credential_modifier_type(event_parameters); + = notification_handler::credential::get_credential_modifier_type( + event_parameters); if (modifier_type == CREDENTIAL_REPORT_DNE) { attribute_store_delete_node(credential_slot_node); } else { @@ -1606,11 +1709,11 @@ void on_notification_event(attribute_store_node_t endpoint_node, trigger_get_user(endpoint_node, 0); } break; // Multiple credential deleted - case 0x26: { + case 0x26: { sl_log_debug(LOG_TAG, "Notification : Multiple credential deleted"); - - if (!notification_handler::credential::is_credential_deletion_size_conform( - event_parameters_length)) { + + if (!notification_handler::credential:: + is_credential_deletion_size_conform(event_parameters_length)) { return; } @@ -1627,15 +1730,18 @@ void on_notification_event(attribute_store_node_t endpoint_node, credential_type, user_id); - auto cred_type_node = notification_handler::credential::get_credential_type_node( - endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); + auto cred_type_node + = notification_handler::credential::get_credential_type_node( + endpoint_node, + event_parameters, + REPORTED_ATTRIBUTE); if (!attribute_store_node_exists(cred_type_node)) { sl_log_error(LOG_TAG, - "Didn't find credential type %d associated with user %d. Can't delete credentials.", - credential_type, user_id); + "Didn't find credential type %d associated with user " + "%d. Can't delete credentials.", + credential_type, + user_id); return; } @@ -1670,15 +1776,17 @@ void on_notification_event(attribute_store_node_t endpoint_node, sl_log_info(LOG_TAG, "All credentials for user %d deleted.", user_id); } else if (credential_type != 0) { // Delete all credentials of a type - auto credential_type_nodes = get_all_credential_type_nodes(endpoint_node, credential_type); - for(auto credential_type_node : credential_type_nodes) { + auto credential_type_nodes + = get_all_credential_type_nodes(endpoint_node, credential_type); + for (auto credential_type_node: credential_type_nodes) { attribute_store_delete_node(credential_type_node); } sl_log_info(LOG_TAG, "Credential of type %d deleted", credential_type); } else { // Delete all credentials - auto credential_type_nodes = get_all_credential_type_nodes(endpoint_node); - for(auto credential_type_node : credential_type_nodes) { + auto credential_type_nodes + = get_all_credential_type_nodes(endpoint_node); + for (auto credential_type_node: credential_type_nodes) { attribute_store_delete_node(credential_type_node); } sl_log_info(LOG_TAG, "All credentials deleted.", user_id); @@ -1936,11 +2044,10 @@ sl_status_t & CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK) > 0; - attribute_store_set_child_reported( - credential_type_node, - ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), - &support_cl, - sizeof(support_cl)); + attribute_store_set_child_reported(credential_type_node, + ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), + &support_cl, + sizeof(support_cl)); // >> 16 bits values auto store_uint16_value = [&](attribute_store_type_t type, uint8_t offset) { @@ -2045,7 +2152,24 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( // Credential Set/Get/Report ///////////////////////////////////////////////////////////////////////////// -// Start credential interview process by starting with 0,0 +/** + * @brief Trigger a GET credential command + * + * Create credential_type if it doesn't exists + * + * If credential_slot exists : + * - Set desired value as reported + * - Clear reported value + * Otherwise : + * - Set desired value + * + * trigger_get_credential(user_node, 0, 0) will trigger a GET command for the first credential of user_node + * + * @param user_unique_id_node User ID node + * @param credential_type 0 to get the first credential; valid value otherwise + * @param credential_slot 0 to get the first credential; valid value otherwise + * +*/ void trigger_get_credential(attribute_store_node_t user_unique_id_node, user_credential_type_t credential_type, user_credential_slot_t credential_slot) @@ -2470,6 +2594,14 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( = get_uint16_value(frame_data, INDEX_NEXT_CREDENTIAL_SLOT); if (next_credential_type != 0 && next_credential_slot != 0) { + if (!is_credential_available(endpoint_node, + next_credential_type, + next_credential_slot)) { + sl_log_debug(LOG_TAG, + "Next credential is already known, skipping discovery."); + return SL_STATUS_OK; + } + trigger_get_credential(user_unique_id_node, next_credential_type, next_credential_slot); @@ -2484,10 +2616,11 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return SL_STATUS_OK; } -sl_status_t zwave_command_class_user_credential_credential_set_error_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) +sl_status_t + zwave_command_class_user_credential_credential_set_error_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) { if (frame_length < 13) { sl_log_warning(LOG_TAG, @@ -2501,63 +2634,83 @@ sl_status_t zwave_command_class_user_credential_credential_set_error_handle_repo user_credential_type_t credential_type = frame_data[5]; user_credential_slot_t credential_slot = get_uint16_value(frame_data, 6); - attribute_store_node_t endpoint_node = zwave_command_class_get_endpoint_node(connection_info); attribute_store_node_t credential_type_node; attribute_store_node_t credential_slot_node; - auto remove_credential_slot_if_possible = [&](attribute_store_node_t credential_slot_node) { - if (attribute_store_node_exists(credential_slot_node)) { - sl_log_debug(LOG_TAG, - "Removing credential slot : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); - attribute_store_delete_node(credential_slot_node); - } else { - sl_log_debug(LOG_TAG, - "No credential slot found for user %d, credential type " - "%d, credential slot %d", - user_id, - credential_type, - credential_slot); - } - }; - switch(error_code) { + auto remove_credential_slot_if_possible + = [&](attribute_store_node_t credential_slot_node) { + if (attribute_store_node_exists(credential_slot_node)) { + sl_log_debug(LOG_TAG, + "Removing credential slot : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + attribute_store_delete_node(credential_slot_node); + } else { + sl_log_debug(LOG_TAG, + "No credential slot found for user %d, credential type " + "%d, credential slot %d", + user_id, + credential_type, + credential_slot); + } + }; + switch (error_code) { // Credential Add Rejected Location Occupied : 0x00 // If attempting to add a credential where a credential of that Credential Type at that Credential Slot already exists, and the new credential data differs case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALADDREJECTEDLOCATIONOCCUPIED: sl_log_error(LOG_TAG, - "Credential data rejected as it already exists : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); + "Credential data rejected as it already exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); // Try to find the node in the store - get_credential_type_node(endpoint_node, user_id, credential_type, DESIRED_ATTRIBUTE, credential_type_node); + get_credential_type_node(endpoint_node, + user_id, + credential_type, + DESIRED_ATTRIBUTE, + credential_type_node); if (!attribute_store_node_exists(credential_type_node)) { - get_credential_type_node(endpoint_node, user_id, credential_type, REPORTED_ATTRIBUTE, credential_type_node); + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); } - - get_credential_slot_node(credential_type_node, credential_slot, DESIRED_ATTRIBUTE, credential_slot_node); + + get_credential_slot_node(credential_type_node, + credential_slot, + DESIRED_ATTRIBUTE, + credential_slot_node); remove_credential_slot_if_possible(credential_slot_node); - break; + break; // Credential Modify Rejected Location Empty : 0x01 case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY: - sl_log_error(LOG_TAG, - "Credential data cannot be modified as it does not exists : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); - + sl_log_error( + LOG_TAG, + "Credential data cannot be modified as it does not exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + // Try to find the node in the store - get_credential_type_node(endpoint_node, user_id, credential_type, DESIRED_ATTRIBUTE, credential_type_node); + get_credential_type_node(endpoint_node, + user_id, + credential_type, + DESIRED_ATTRIBUTE, + credential_type_node); if (!attribute_store_node_exists(credential_type_node)) { - get_credential_type_node(endpoint_node, user_id, credential_type, REPORTED_ATTRIBUTE, credential_type_node); + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); } if (!attribute_store_node_exists(credential_type_node)) { @@ -2568,114 +2721,423 @@ sl_status_t zwave_command_class_user_credential_credential_set_error_handle_repo return SL_STATUS_OK; } - get_credential_slot_node(credential_type_node, credential_slot, DESIRED_ATTRIBUTE, credential_slot_node); + get_credential_slot_node(credential_type_node, + credential_slot, + DESIRED_ATTRIBUTE, + credential_slot_node); if (!attribute_store_node_exists(credential_slot_node)) { - get_credential_slot_node(credential_type_node, credential_slot, REPORTED_ATTRIBUTE, credential_slot_node); + get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); } remove_credential_slot_if_possible(credential_slot_node); - break; + break; // Duplicate Credential : 0x02 case CREDENTIAL_SET_ERROR_REPORT_DUPLICATECREDENTIAL: - // Do nothing, the credential GET will clean up for us - sl_log_warning(LOG_TAG, - "Duplicate Credential for user %d, credential type %d, " - "credential slot %d", - user_id, - credential_type, - credential_slot); - break; + // Do nothing, the credential GET will clean up for us + sl_log_warning(LOG_TAG, + "Duplicate Credential for user %d, credential type %d, " + "credential slot %d", + user_id, + credential_type, + credential_slot); + break; // Manufacturer Security Rules : 0x03 case CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES: - // Do nothing, the credential GET will clean up for us - sl_log_warning( - LOG_TAG, - "Credential data rejected as it doesn't respect manufacturer " - "security rules : user %d, credential type %d, " - "credential slot %d", - user_id, - credential_type, - credential_slot); - break; + // Do nothing, the credential GET will clean up for us + sl_log_warning( + LOG_TAG, + "Credential data rejected as it doesn't respect manufacturer " + "security rules : user %d, credential type %d, " + "credential slot %d", + user_id, + credential_type, + credential_slot); + break; } return SL_STATUS_OK; } + ///////////////////////////////////////////////////////////////////////////// -// User Set/Get/Report/Set Error Report +// Credential Learn Start/Report/Stop ///////////////////////////////////////////////////////////////////////////// - -// Start user interview process by starting a user get with ID 0 -void trigger_get_user(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) -{ - // If we are not in the special case of user ID 0 we need to check if user is already here - if (user_id != 0) { - attribute_store_node_t user_node - = attribute_store_get_node_child_by_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - // If it exists we interview it again - if (attribute_store_node_exists(user_node)) { - sl_log_debug( - LOG_TAG, - "User Unique ID %d found. Undefine its reported value to update it.", - user_id); - attribute_store_set_desired(user_node, &user_id, sizeof(user_id)); - attribute_store_undefine_reported(user_node); - return; - } - } - - // If user id is 0 or not existant we create it - sl_log_debug(LOG_TAG, "Creating User Unique ID node %d", user_id); - attribute_store_emplace_desired(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); -} - -static sl_status_t zwave_command_class_user_credential_user_set( - attribute_store_node_t user_operation_type_node, +static sl_status_t zwave_command_class_user_credential_credential_learn_start( + attribute_store_node_t credential_operation_type_node, uint8_t *frame, uint16_t *frame_length) { - // Get user unique id node + // Identifiers nodes + attribute_store_node_t credential_slot_node + = attribute_store_get_first_parent_with_type(credential_operation_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store_node_t credential_type_node + = attribute_store_get_first_parent_with_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_TYPE)); attribute_store_node_t user_unique_id_node - = attribute_store_get_first_parent_with_type(user_operation_type_node, + = attribute_store_get_first_parent_with_type(credential_type_node, ATTRIBUTE(USER_UNIQUE_ID)); - user_credential_user_unique_id_t user_id = 0; - attribute_store_get_desired_else_reported(user_unique_id_node, - &user_id, - sizeof(user_id)); + // Get operation type + user_credential_operation_type_t operation_type = 0; + sl_status_t status + = attribute_store_get_desired(credential_operation_type_node, + &operation_type, + sizeof(operation_type)); - // If we can't get the user unique id we can't continue - if (!attribute_store_node_exists(user_unique_id_node)) { + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't get operation type. Not sending Credential Learn Start."); return SL_STATUS_NOT_SUPPORTED; } - user_credential_operation_type_t user_operation_type = 0; - sl_status_t status = attribute_store_get_desired(user_operation_type_node, - &user_operation_type, - sizeof(user_operation_type)); - - sl_log_debug(LOG_TAG, - "User SET for user %d (operation type : %d)", - user_id, - user_operation_type); + auto credential_learn_timeout_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get user operation type value. Not sending USER_SET."); - return SL_STATUS_NOT_SUPPORTED; - } + sl_log_debug( + LOG_TAG, + "Credential Learn Start for Credential Slot %d, Credential Type %d, " + "User %d (operation type : %d, timeout : %d)", + static_cast( + attribute_store_get_reported_number(credential_slot_node)), + static_cast( + attribute_store_get_reported_number(credential_type_node)), + static_cast( + attribute_store_get_reported_number(user_unique_id_node)), + operation_type, + static_cast( + attribute_store_get_reported_number(credential_learn_timeout_node))); + // Since the data is not linear we provide the node directly std::vector set_data - = {{ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, + = {{ATTRIBUTE(USER_UNIQUE_ID), + DESIRED_OR_REPORTED_ATTRIBUTE, + user_unique_id_node}, + {ATTRIBUTE(CREDENTIAL_TYPE), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_type_node}, + {ATTRIBUTE(CREDENTIAL_SLOT), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_slot_node}, + {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + DESIRED_ATTRIBUTE, + credential_operation_type_node}, + {ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + DESIRED_OR_REPORTED_ATTRIBUTE, + credential_learn_timeout_node}}; + + status = create_command_frame(CREDENTIAL_LEARN_START, + set_data, + credential_slot_node, + frame, + frame_length); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, "Can't create Credential Learn Start"); + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + +static sl_status_t zwave_command_class_user_credential_credential_learn_cancel( + attribute_store_node_t credential_learn_stop_node, + uint8_t *frame, + uint16_t *frame_length) +{ + uint8_t stop_flag = 1; + attribute_store_set_reported(credential_learn_stop_node, + &stop_flag, + sizeof(stop_flag)); + attribute_store_undefine_desired(credential_learn_stop_node); + + frame[0] = COMMAND_CLASS_USER_CREDENTIAL; + frame[1] = CREDENTIAL_LEARN_CANCEL; + + *frame_length = 2; + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_status_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + constexpr uint8_t EXPECTED_FRAME_LENGTH = 9; + if (frame_length != EXPECTED_FRAME_LENGTH) { + sl_log_error(LOG_TAG, + "CREDENTIAL_LEARN_STATUS_REPORT frame length is not valid. Expected %d, got %d", + EXPECTED_FRAME_LENGTH, + frame_length); + return SL_STATUS_NOT_SUPPORTED; + } + + constexpr uint8_t INDEX_LEARN_STATUS = 2; + constexpr uint8_t INDEX_USER_ID = 3; + constexpr uint8_t INDEX_CREDENTIAL_TYPE = 5; + constexpr uint8_t INDEX_CREDENTIAL_SLOT = 6; + constexpr uint8_t INDEX_CREDENTIAL_LEARN_STEP_REMAINING = 8; + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // Interpret frame + const uint8_t learn_status = frame_data[INDEX_LEARN_STATUS]; + const user_credential_user_unique_id_t user_id + = get_uint16_value(frame_data, INDEX_USER_ID); + const user_credential_type_t credential_type + = frame_data[INDEX_CREDENTIAL_TYPE]; + const user_credential_slot_t credential_slot + = get_uint16_value(frame_data, INDEX_CREDENTIAL_SLOT); + const uint8_t step_remaining + = frame_data[INDEX_CREDENTIAL_LEARN_STEP_REMAINING]; + + sl_log_debug(LOG_TAG, + "Credential Learn Status Report. Credential Type: %d / " + "Credential Slot: %d (User %d)", + credential_type, + credential_slot, + user_id); + + // Get the nodes + attribute_store_node_t credential_type_node; + attribute_store_node_t credential_slot_node; + + get_credential_type_node(endpoint_node, + user_id, + credential_type, + DESIRED_ATTRIBUTE, + credential_type_node); + if (!attribute_store_node_exists(credential_type_node)) { + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + } + get_credential_slot_node(credential_type_node, + credential_slot, + DESIRED_ATTRIBUTE, + credential_slot_node); + if (!attribute_store_node_exists(credential_slot_node)) { + get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); + } + + if (!attribute_store_node_exists(credential_slot_node) + || !attribute_store_node_exists(credential_type_node)) { + sl_log_error(LOG_TAG, + "Can't find User %d, Credential Type %d, " + "Credential Slot %d reported by Credential Learn Status", + user_id, + credential_type, + credential_slot); + return SL_STATUS_NOT_SUPPORTED; + } + + // Get operation type so we can handle error cases + auto credential_learn_operation_type_node + = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)); + + user_credential_operation_type_t operation_type = 0; + sl_status_t status + = attribute_store_get_desired(credential_learn_operation_type_node, + &operation_type, + sizeof(operation_type)); + + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't get learn operation type. Ignoring Credential Learn Report."); + return SL_STATUS_NOT_SUPPORTED; + } + + // Action based of current learn status + switch (learn_status) { + case CREDENTIAL_LEARN_REPORT_STARTED: + sl_log_info(LOG_TAG, + "Credential Learn Started for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + break; + case CREDENTIAL_LEARN_REPORT_SUCCESS: + sl_log_info(LOG_TAG, + "Credential Learn Success for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + break; + case CREDENTIAL_LEARN_REPORT_ALREADY_IN_PROGRESS: + sl_log_warning( + LOG_TAG, + "Credential Learn already in progress for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + break; + case CREDENTIAL_LEARN_REPORT_ENDED_NOT_DUE_TO_TIMEOUT: + sl_log_info(LOG_TAG, + "Credential Learn ended not due to timeout for User %d, " + "Credential Type %d, Credential Slot %d", + user_id, + credential_type, + credential_slot); + // Handle error case for add, remove the current slot + if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { + attribute_store_delete_node(credential_slot_node); + } + break; + case CREDENTIAL_LEARN_REPORT_TIMEOUT: + sl_log_warning( + LOG_TAG, + "Credential Learn Timeout for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + // Handle error case for add, remove the current slot + if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { + attribute_store_delete_node(credential_slot_node); + } + break; + case 0x05: // Credential Learn Step Retry + sl_log_info( + LOG_TAG, + "Credential Learn Step Needs a Retry for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + // Handle error case for add, remove the current slot + if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { + attribute_store_delete_node(credential_slot_node); + } + break; + case CREDENTIAL_LEARN_REPORT_INVALID_ADD_OPERATION_TYPE: + sl_log_error( + LOG_TAG, + "Invalid Add Operation Type for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + break; + case CREDENTIAL_LEARN_REPORT_INVALID_MODIFY_OPERATION_TYPE: + sl_log_error( + LOG_TAG, + "Invalid Modify Operation Type for User %d, Credential Type %d, " + "Credential Slot %d", + user_id, + credential_type, + credential_slot); + // Handle error case for add, remove the current slot + if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { + attribute_store_delete_node(credential_slot_node); + } + break; + } + + // Update attribute store + status = attribute_store_set_child_reported( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), + &step_remaining, + sizeof(step_remaining)); + + status |= attribute_store_set_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_STATUS), + &learn_status, + sizeof(learn_status)); + return status; +} +///////////////////////////////////////////////////////////////////////////// +// User Set/Get/Report/Set Error Report +///////////////////////////////////////////////////////////////////////////// + +// Start user interview process by starting a user get with ID 0 +void trigger_get_user(attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + // If we are not in the special case of user ID 0 we need to check if user is already here + if (user_id != 0) { + attribute_store_node_t user_node + = attribute_store_get_node_child_by_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&user_id, + sizeof(user_id), + 0); + // If it exists we interview it again + if (attribute_store_node_exists(user_node)) { + sl_log_debug( + LOG_TAG, + "User Unique ID %d found. Undefine its reported value to update it.", + user_id); + attribute_store_set_desired(user_node, &user_id, sizeof(user_id)); + attribute_store_undefine_reported(user_node); + return; + } + } + + // If user id is 0 or not existant we create it + sl_log_debug(LOG_TAG, "Creating User Unique ID node %d", user_id); + attribute_store_emplace_desired(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); +} + +static sl_status_t zwave_command_class_user_credential_user_set( + attribute_store_node_t user_operation_type_node, + uint8_t *frame, + uint16_t *frame_length) +{ + // Get user unique id node + attribute_store_node_t user_unique_id_node + = attribute_store_get_first_parent_with_type(user_operation_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + user_credential_user_unique_id_t user_id = 0; + attribute_store_get_desired_else_reported(user_unique_id_node, + &user_id, + sizeof(user_id)); + + // If we can't get the user unique id we can't continue + if (!attribute_store_node_exists(user_unique_id_node)) { + return SL_STATUS_NOT_SUPPORTED; + } + + user_credential_operation_type_t user_operation_type = 0; + sl_status_t status = attribute_store_get_desired(user_operation_type_node, + &user_operation_type, + sizeof(user_operation_type)); + + sl_log_debug(LOG_TAG, + "User SET for user %d (operation type : %d)", + user_id, + user_operation_type); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get user operation type value. Not sending USER_SET."); + return SL_STATUS_NOT_SUPPORTED; + } + + std::vector set_data + = {{ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, {ATTRIBUTE(USER_UNIQUE_ID), DESIRED_OR_REPORTED_ATTRIBUTE, user_unique_id_node}}; @@ -2716,26 +3178,26 @@ static sl_status_t zwave_command_class_user_credential_user_get( sl_status_t status = attribute_store_get_desired(node, &user_id, sizeof(user_id)); - // If we enter this state it means that something went badly wrong or - // user initiate the interview process again. + // If we enter this state it means that something went badly wrong or + // user initiate the interview process again. // In both cases we want to invalidate the user database so that the device // can send us the correct user database. if (status != SL_STATUS_OK) { sl_log_warning(LOG_TAG, - "Can't get user unique id value. Reset user database."); + "Can't get user unique id value. Reset user database."); attribute_store_node_t endpoint_node = attribute_store_get_node_parent(node); - // Get User node count - auto user_count = attribute_store_get_node_child_count_by_type( - endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID)); + // Get User node count + auto user_count + = attribute_store_get_node_child_count_by_type(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID)); for (size_t j = 0; j < user_count; j++) { // Delete the first attribute we find until we have no more left attribute_store_node_t user_node = attribute_store_get_node_child_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - 0); + ATTRIBUTE(USER_UNIQUE_ID), + 0); attribute_store_delete_node(user_node); } // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. @@ -3030,9 +3492,12 @@ void zwave_network_status_changed(attribute_store_node_t updated_node, auto user_count = attribute_store_get_node_child_count_by_type( endpoint_node, ATTRIBUTE(USER_UNIQUE_ID)); - sl_log_debug(LOG_TAG, "Endpoint %d supports User Credential.", endpoint_id); + sl_log_debug(LOG_TAG, + "Endpoint %d supports User Credential.", + endpoint_id); if (user_count == 0) { - sl_log_debug(LOG_TAG, "No user found. Starting User and Credential interview"); + sl_log_debug(LOG_TAG, + "No user found. Starting User and Credential interview"); // Start the interview process with user ID = 0 trigger_get_user(endpoint_node, 0); } else { @@ -3088,7 +3553,10 @@ sl_status_t zwave_command_class_user_credential_add_new_user( // Check capabilites user_capabilities capabilites = get_user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, user_type, credential_rule, user_name)) { + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); return SL_STATUS_FAIL; } @@ -3211,7 +3679,10 @@ sl_status_t zwave_command_class_user_credential_modify_user( // Check capabilites user_capabilities capabilites = get_user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, user_type, credential_rule, user_name)) { + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); return SL_STATUS_FAIL; } @@ -3306,15 +3777,7 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( user_credential_slot_t credential_slot, const char *credential_data) { - // First see if the user exists - auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "Can't find user with ID %d. Not adding credentials.", - user_id); - return SL_STATUS_FAIL; - } - + // Check if parameters are ok if (credential_type == 0 || credential_slot == 0) { sl_log_error( LOG_TAG, @@ -3326,59 +3789,29 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - auto credential_type_nodes - = get_all_credential_type_nodes(endpoint_node, credential_type); - - // Credential type, Credential Node pair is Unique - for (auto &credential_type_node : credential_type_nodes) { - user_credential_type_t current_type; - attribute_store_get_reported(credential_type_node, - ¤t_type, - sizeof(current_type)); - user_credential_slot_t current_slot; - attribute_store_get_child_reported(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - ¤t_slot, - sizeof(current_slot)); - if (current_slot == credential_slot && current_type == credential_type) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists. " - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; } - // First check Credential Type existance - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - if (attribute_store_node_exists(credential_type_node)) { - get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - - // If a Credential Slot already exists we can't add a new one - if (attribute_store_node_exists(credential_slot_node)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists. " - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + // Get or create credential type node + credential_type_node = add_credential_type_node_if_missing(endpoint_node, + user_id, + credential_type); - } else { - // Create Credential Type if it doesn't exists - credential_type_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error(LOG_TAG, + "Can't find Credential Type %d for User %d. Not adding " + "credentials.", + credential_type, + user_id); + return SL_STATUS_FAIL; } // Debug info @@ -3401,7 +3834,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - auto capabilities = get_credential_capabilities(endpoint_node, credential_type); @@ -3421,8 +3853,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( &credential_slot, sizeof(credential_slot)); - - // Add data uint8_t data_size = credential_data_vector.size(); auto credential_data_length_node @@ -3636,11 +4066,10 @@ sl_status_t zwave_command_class_user_credential_delete_all_users( return SL_STATUS_OK; } - void trigger_credential_deletion(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) { attribute_store_node_t user_id_node = attribute_store_emplace(endpoint_node, @@ -3722,6 +4151,204 @@ sl_status_t return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_credential_learn_start_add( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) +{ + auto credential_capabilities + = get_credential_capabilities(endpoint_node, credential_type); + + if (!credential_capabilities.is_learn_supported()) { + sl_log_error(LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } + + if (!credential_capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d is not valid for Credential Type %d. Not " + "starting learn process.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + // Create or update existing structure + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + // Get or add credential type node + credential_type_node = add_credential_type_node_if_missing(endpoint_node, + user_id, + credential_type); + + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error(LOG_TAG, + "Can't find Credential Type %d for User %d. Not adding " + "credentials.", + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (Add)" + " called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.learn_recommended_timeout; + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } + + // Create credential slot with reported value since we don't want + // to trigger a Credential Get right away + credential_slot_node = attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + + // Set attributes for Credential Learn + attribute_store_set_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + &credential_learn_timeout, + sizeof(credential_learn_timeout)); + + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) +{ + auto credential_capabilities + = get_credential_capabilities(endpoint_node, credential_type); + + if (!credential_capabilities.is_learn_supported()) { + sl_log_error(LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } + + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + // Get current structure + attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; + + get_credential_type_node(endpoint_node, + user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + get_credential_slot_node(credential_type_node, + credential_slot, + REPORTED_ATTRIBUTE, + credential_slot_node); + + if (!attribute_store_node_exists(credential_type_node) + || !attribute_store_node_exists(credential_slot_node)) { + sl_log_error(LOG_TAG, + "Can't find Credential Type %d for User %d. Not adding " + "credentials.", + credential_type, + user_id); + return SL_STATUS_FAIL; + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (modify) " + "called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.learn_recommended_timeout; + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } + + // Set attributes for Credential Learn + attribute_store_set_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + &credential_learn_timeout, + sizeof(credential_learn_timeout)); + + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_stop( + attribute_store_node_t endpoint_node) +{ + uint8_t stop_flag = 1; + + return attribute_store_set_child_desired(endpoint_node, + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &stop_flag, + sizeof(stop_flag)); +} + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// @@ -3772,6 +4399,11 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case CREDENTIAL_LEARN_REPORT: + return zwave_command_class_user_credential_credential_learn_status_report( + connection_info, + frame_data, + frame_length); default: return SL_STATUS_NOT_SUPPORTED; } @@ -3819,6 +4451,16 @@ sl_status_t zwave_command_class_user_credential_init() &zwave_command_class_user_credential_credential_set, NULL); + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_learn_start, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &zwave_command_class_user_credential_credential_learn_cancel, + NULL); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 1ea7ce574..3edfb0715 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -243,6 +243,60 @@ sl_status_t user_credential_user_unique_id_t user_id, user_credential_type_t credential_type); + +/** + * @brief Send new credential command (Credential Learn Start) with operation type Add to the end device + * + * @note The credential type must be supporting the Credential Learn feature. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Can exist or not. Cannot be 0. + * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. + * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential type doesn't support the learn mode. + */ +sl_status_t zwave_command_class_user_credential_credential_learn_start_add( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout); + +/** + * @brief Send new credential command (Credential Learn Start) with operation type Modify to the end device + * + * @note The credential type must be supporting the Credential Learn feature. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot/credential type is 0 or does not exists. Also if the credential type doesn't support the learn mode. + */ +sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout); + +/** + * @brief Send new credential command (Credential Learn Stop) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_credential_learn_stop( + attribute_store_node_t endpoint_node); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 13f9ee55e..041272831 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -66,7 +66,9 @@ static std::map attributes_binding {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, - {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}}; + {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}, + {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), {0, CREDENTIAL_LEARN_START}}, + {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}}; // Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on // attributes_binding map. @@ -287,8 +289,7 @@ void helper_simulate_credential_capabilites_report( std::vector min_length, std::vector max_length, std::vector cl_timeout, - std::vector cl_steps - ) + std::vector cl_steps) { if (credential_type.size() != cl_support.size() || credential_type.size() != supported_credential_slots.size() @@ -345,6 +346,42 @@ void helper_simulate_credential_capabilites_report( SL_STATUS_OK, handler.control_handler(&info, report_frame.data(), report_frame.size())); }; + +void helper_create_learn_status_report_frame( + uint8_t credential_learn_status, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + uint8_t learn_steps_remaining) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_LEARN_REPORT}; + + report_frame.push_back(credential_learn_status); + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(credential_type); + + auto exploded_credential_slot = explode_uint16(credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(learn_steps_remaining); + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +} + /** * @brief Create credential structure and return associated nodes * @@ -582,6 +619,88 @@ void helper_test_string_value( } } +void helper_test_credential_learn_structure( + attribute_store_node_t user_id_node, + attribute_store_node_t credential_type_node, + attribute_store_node_t credential_slot_node, + user_credential_learn_timeout_t expected_cl_timeout, + user_credential_operation_type_t expected_operation_type) +{ + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential type slot should exist"); + + uint8_t current_cl_timeout = 0; + auto cred_learn_timeout_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)); + attribute_store_get_reported(cred_learn_timeout_node, + ¤t_cl_timeout, + sizeof(current_cl_timeout)); + + TEST_ASSERT_EQUAL_MESSAGE(expected_cl_timeout, + current_cl_timeout, + "Timeout value mismatch."); + + user_credential_operation_type_t operation_type = 6; + auto operation_type_node = attribute_store_get_node_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + 0); + attribute_store_get_desired(operation_type_node, + &operation_type, + sizeof(operation_type)); + + TEST_ASSERT_EQUAL_MESSAGE(expected_operation_type, + operation_type, + "Operation type should be learn add"); + + auto credential_type_state + = expected_operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD + ? DESIRED_ATTRIBUTE + : REPORTED_ATTRIBUTE; + + helper_test_set_get_with_args( + CREDENTIAL_LEARN_START, + operation_type_node, + {{user_id_node, REPORTED_ATTRIBUTE}, + {credential_type_node, credential_type_state}, + {credential_slot_node, REPORTED_ATTRIBUTE}, + {operation_type_node, DESIRED_ATTRIBUTE}, + {cred_learn_timeout_node, REPORTED_ATTRIBUTE}}); + + user_credential_user_unique_id_t user_id; + user_credential_type_t credential_type; + user_credential_slot_t credential_slot; + + attribute_store_get_reported(user_id_node, &user_id, sizeof(user_id)); + attribute_store_read_value(credential_type_node, + credential_type_state, + &credential_type, + sizeof(credential_type)); + attribute_store_get_reported(credential_slot_node, + &credential_slot, + sizeof(credential_slot)); + + uint8_t step_remaining = 2; + user_credential_learn_status_t learn_status = CREDENTIAL_LEARN_REPORT_SUCCESS; + helper_create_learn_status_report_frame(learn_status, + user_id, + credential_type, + credential_slot, + step_remaining); + + std::map uint8_attribute_map = { + {ATTRIBUTE(CREDENTIAL_LEARN_STATUS), learn_status}, + {ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), step_remaining}, + }; + + helper_test_attribute_store_values(uint8_attribute_map, credential_slot_node); +}; + ///////////////////////////////////////////////////// // Test case ///////////////////////////////////////////////////// @@ -816,8 +935,8 @@ void test_user_credential_credential_capabilities_report_happy_case() std::vector supported_credential_slots = {1233, 11233, 21233, 33}; std::vector min_length = {2, 2362, 255, 1255}; std::vector max_length = {5632, 15632, 25632, 32568}; - std::vector cl_timeout = {100, 0, 0, 128}; - std::vector cl_steps = {2, 0, 0, 12}; + std::vector cl_timeout = {100, 0, 0, 128}; + std::vector cl_steps = {2, 0, 0, 12}; uint16_t expected_credential_type_mask = 0b11101; auto test_report_values = [&]() { @@ -2393,10 +2512,11 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, status, - "Credential add should have returned SL_STATUS_FAIL (trying to add same credential type/slot to same user)."); + "Credential add should have returned SL_STATUS_FAIL (trying to add same " + "credential type/slot to same user)."); // Try to add same credential type/slot on other user - user_id = 15; + user_id = 15; attribute_store_emplace(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), &user_id, @@ -2412,7 +2532,8 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, status, - "Credential add should have returned SL_STATUS_FAIL (trying to add same credential type/slot to different user)."); + "Credential add should have returned SL_STATUS_FAIL (trying to add same " + "credential type/slot to different user)."); } void test_user_credential_user_notification_add_modify_delete_happy_case() @@ -3971,4 +4092,471 @@ void test_user_credential_remove_all_credentials_by_type() TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), "User 0 should not exists"); } + +void test_user_credential_credential_learn_start_add_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Add credential + // Test if we give 0 as timeout, it should be set to default value + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Should be able to start learning"); + + attribute_store_node_t credential_type_node; + attribute_store_node_t credential_slot_node; + auto update_credential_nodes = [&]() { + credential_type_node + = attribute_store_get_node_child_by_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + DESIRED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + credential_slot_node + = attribute_store_get_node_child_by_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_slot, + sizeof(credential_slot), + 0); + }; + + update_credential_nodes(); + helper_test_credential_learn_structure(user_id_node, + credential_type_node, + credential_slot_node, + supported_cl_timeout[0], + USER_CREDENTIAL_OPERATION_TYPE_ADD); + + // Test with specific timeout + credential_type = ZCL_CRED_TYPE_HAND_BIOMETRIC; + credential_slot = 1; + cl_timeout = 100; + + status = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Should be able to start learning"); + + update_credential_nodes(); + helper_test_credential_learn_structure(user_id_node, + credential_type_node, + credential_slot_node, + cl_timeout, + USER_CREDENTIAL_OPERATION_TYPE_ADD); +} + +void test_user_credential_credential_learn_start_add_cl_not_supported() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {0, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {0, 2}; + std::vector supported_cl_steps = {0, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning"); +} + +void test_user_credential_credential_learn_start_add_slot_not_supported() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 6; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {10, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning"); +} + +void test_user_credential_credential_learn_start_add_type_not_supported() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_BLE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {10, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning"); +} + +void test_user_credential_credential_learn_start_add_credential_already_exists() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + user_id = 15; + auto user_id_node = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + auto credential_type_node + = attribute_store_emplace(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + attribute_store_emplace(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slot, + sizeof(credential_slot)); + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {10, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_add( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning"); +} + +void test_user_credential_credential_learn_start_modify_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + auto credential_nodes + = helper_create_credential_structure(user_id, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Add credential + // Test if we give 0 as timeout, it should be set to default value + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_modify( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Should be able to start learning (modify)"); + + helper_test_credential_learn_structure(credential_nodes.user_id_node, + credential_nodes.credential_type_node, + credential_nodes.credential_slot_node, + supported_cl_timeout[0], + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + + // Test with specific timeout + credential_type = ZCL_CRED_TYPE_HAND_BIOMETRIC; + credential_slot = 1; + cl_timeout = 100; + credential_nodes = helper_create_credential_structure(user_id, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + + status = zwave_command_class_user_credential_credential_learn_start_modify( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Should be able to start learning (modify)"); + helper_test_credential_learn_structure(credential_nodes.user_id_node, + credential_nodes.credential_type_node, + credential_nodes.credential_slot_node, + cl_timeout, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); +} + +void test_user_credential_credential_learn_start_modify_cl_not_supported() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + // Simulate user + helper_create_credential_structure(user_id, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {0, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {0, 2}; + std::vector supported_cl_steps = {0, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_modify( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning (modify)"); +} + +void test_user_credential_credential_learn_start_modify_credential_not_existing() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 1; + user_credential_learn_timeout_t cl_timeout = 0; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Set capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {0, 1}; + std::vector supported_credential_slots = {1, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {0, 2}; + std::vector supported_cl_steps = {0, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + sl_status_t status + = zwave_command_class_user_credential_credential_learn_start_modify( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + cl_timeout); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Should not be able to start learning (modify)"); +} + +void test_user_credential_credential_learn_cancel_happy_case() { + uint8_t stop_flag = 0; + auto stop_node + = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &stop_flag, + sizeof(stop_flag)); + + auto &get_func = resolver_functions[CREDENTIAL_LEARN_CANCEL]; + + // Ask for a Get Command, should always be the same + TEST_ASSERT_NOT_NULL_MESSAGE( + get_func, + "Couldn't find get function in resolver_functions."); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + get_func(stop_node, received_frame, &received_frame_size), + "Get function should have returned OK"); + + attribute_store_get_reported(stop_node, &stop_flag, sizeof(stop_flag)); + TEST_ASSERT_EQUAL_MESSAGE(1, + stop_flag, + "Stop flag should have been set to 1"); +} + } // extern "C" \ No newline at end of file From 52ce7d826563d23c3712c03dc1b721c1b884a8a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 29 May 2024 11:26:36 +0200 Subject: [PATCH 16/60] UIC-3222: Enforce Capabilities of Credential Slot Verify that the slot we are trying to add is in range of supported slots --- .../zwave_command_class_user_credential.cpp | 16 ++++++- ...ave_command_class_user_credential_test.cpp | 43 +++++++++++++++++++ 2 files changed, 57 insertions(+), 2 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 56e08dbee..95edd12e4 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -3785,6 +3785,18 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } + auto capabilities + = get_credential_capabilities(endpoint_node, credential_type); + + if (!capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d is not valid. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + // Create or update existing structure attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; @@ -3800,6 +3812,8 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } + + // Get or create credential type node credential_type_node = add_credential_type_node_if_missing(endpoint_node, user_id, @@ -3834,8 +3848,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - auto capabilities - = get_credential_capabilities(endpoint_node, credential_type); if (!capabilities.is_credential_valid(credential_type, credential_slot, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 041272831..4892d3a7e 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2536,6 +2536,49 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() "credential type/slot to different user)."); } +void test_user_credential_add_credential_invalid_slot() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t credential_slot = 58; + std::string credential_data = "12"; + + // Simulate user + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + // Se capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); + + // Add credential + sl_status_t status = zwave_command_class_user_credential_add_new_credential( + endpoint_id_node, + user_id, + credential_type, + credential_slot, + credential_data.c_str()); + + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Credential add should have returned SL_STATUS_FAIL (trying to add a non supported slot)"); +} + void test_user_credential_user_notification_add_modify_delete_happy_case() { // Initialize the notification callback From 62f08709189574870968a11c3b8acce8f92fa274 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 10 Jun 2024 14:40:18 +0200 Subject: [PATCH 17/60] UIC-3222: User Unique Identifier Credential Association commands --- .../src/user_credential_cluster_server.cpp | 117 ++-- .../user_credential_cluster_server_test.cpp | 116 ++- .../attribute_store_defined_attribute_types.h | 10 +- .../zpc_attribute_store_type_registration.cpp | 3 + .../zwave_command_class_user_credential.cpp | 331 +++++++++ .../src/zwave_command_class_user_credential.h | 22 + ...ave_command_class_user_credential_test.cpp | 661 +++++++++++++++++- 7 files changed, 1195 insertions(+), 65 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 6161b4272..2b561067c 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -99,7 +99,8 @@ static const user_attributes_mqtt_map_t credential_attributes {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), {"CredentialModifierType", user_modifier_type_get_enum_value_name}}, {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), {"CredentialModifierNodeId"}}, - {ATTRIBUTE(CREDENTIAL_DATA), {"CredentialData"}}}; + {ATTRIBUTE(CREDENTIAL_DATA), {"CredentialData"}}, + {ATTRIBUTE(ASSOCIATION_STATUS), {"AssociationStatus"}}}; static const user_attributes_mqtt_map_t credential_rules_attributes = {{ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), {"LearnSupport", convert_to_bool}}, @@ -189,7 +190,6 @@ static sl_status_t return SL_STATUS_OK; } - static sl_status_t delete_user_command(dotdot_unid_t unid, dotdot_endpoint_id_t endpoint, @@ -303,9 +303,10 @@ static sl_status_t credential_slot); } -static sl_status_t delete_all_users_command(dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type) +static sl_status_t + delete_all_users_command(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -347,11 +348,11 @@ static sl_status_t endpoint_node); } -static sl_status_t delete_all_credentials_by_type( - dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type, - CredType credential_type) +static sl_status_t + delete_all_credentials_by_type(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -424,14 +425,14 @@ static sl_status_t delete_all_credentials_for_user_by_type( static_cast(credential_type)); } -sl_status_t credential_learn_start_add( - dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type, - uint16_t user_uniqueid, - CredType credential_type, - uint16_t credential_slot, - uint8_t credential_learn_timeout) +sl_status_t + credential_learn_start_add(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + uint8_t credential_learn_timeout) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -455,14 +456,14 @@ sl_status_t credential_learn_start_add( credential_learn_timeout); } -sl_status_t credential_learn_start_modify( - dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type, - uint16_t user_uniqueid, - CredType credential_type, - uint16_t credential_slot, - uint8_t credential_learn_timeout) +sl_status_t + credential_learn_start_modify(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid, + CredType credential_type, + uint16_t credential_slot, + uint8_t credential_learn_timeout) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -486,11 +487,10 @@ sl_status_t credential_learn_start_modify( credential_learn_timeout); } - -sl_status_t credential_learn_stop( - dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type) +sl_status_t + credential_learn_stop(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -509,6 +509,39 @@ sl_status_t credential_learn_stop( return zwave_command_class_user_credential_credential_learn_stop( endpoint_node); } + +sl_status_t uuic_association_set(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type, + uint16_t source_user_uniqueid, + uint16_t source_credential_slot, + uint16_t destination_user_uniqueid, + uint16_t destination_credential_slot) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_uuic_association_set( + endpoint_node, + static_cast(credential_type), + source_user_uniqueid, + source_credential_slot, + destination_user_uniqueid, + destination_credential_slot); +} + /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -577,8 +610,7 @@ std::string get_base_mqtt_topic(attribute_store::attribute updated_node_cpp) std::string get_base_user_mqtt_topic(attribute_store::attribute updated_node_cpp) { - boost::format mqtt_topic - = boost::format("%1%/User/%2%"); + boost::format mqtt_topic = boost::format("%1%/User/%2%"); std::string base_mqtt_topic = get_base_mqtt_topic(updated_node_cpp); if (base_mqtt_topic.empty()) { @@ -590,8 +622,7 @@ std::string = updated_node_cpp.first_parent_or_self(ATTRIBUTE(USER_UNIQUE_ID)) .reported(); - return (mqtt_topic % base_mqtt_topic % user_id) - .str(); + return (mqtt_topic % base_mqtt_topic % user_id).str(); } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while publishing User attribute (%s) : %s", @@ -644,8 +675,8 @@ std::string return ""; } -std::string - get_base_credential_rule_mqtt_topic(attribute_store::attribute updated_node_cpp) +std::string get_base_credential_rule_mqtt_topic( + attribute_store::attribute updated_node_cpp) { std::string base_user_mqtt_topic = get_base_mqtt_topic(updated_node_cpp); if (base_user_mqtt_topic.empty()) { @@ -730,15 +761,15 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, case BYTE_ARRAY_STORAGE_TYPE: { // Convert the byte array to a string // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value - + std::string output; auto data = updated_node_cpp.reported>(); // Check if we need to convert the value to UTF-8 if (need_utf8_conversion) { std::u16string utf16_str; - for(size_t i=0; i, char16_t> cnv; @@ -789,7 +820,6 @@ void publish_mqtt_topic(const std::string &base_topic, std::string payload_str = ""; if (change != ATTRIBUTE_DELETED) { - if (updated_node_cpp.type() == ATTRIBUTE(CREDENTIAL_DATA)) { // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value // We need to convert the value to UTF-8 if the credential type is password @@ -934,8 +964,9 @@ sl_status_t user_credential_cluster_server_init() &credential_learn_start_modify); uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set( &credential_learn_stop); - + // UUIC association + uic_mqtt_dotdot_user_credential_credential_association_callback_set( + &uuic_association_set); return SL_STATUS_OK; } - diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index e98cd917e..3838d17a4 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -82,6 +82,7 @@ uic_mqtt_dotdot_user_credential_delete_all_credentials_for_user_by_type_callback uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t credential_learn_start_add_command = NULL; uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t credential_learn_start_modify_command = NULL; uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t credential_learn_stop_command = NULL; +uic_mqtt_dotdot_user_credential_credential_association_callback_t credential_association_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -183,6 +184,14 @@ void uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub( credential_learn_stop_command = callback; } +void uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub( + const uic_mqtt_dotdot_user_credential_credential_association_callback_t + callback, + int cmock_num_calls) +{ + credential_association_command = callback; +} + /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() { @@ -260,6 +269,8 @@ void setUp() uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_set_stub); uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_set_stub); uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub); + // UUIC association + uic_mqtt_dotdot_user_credential_credential_association_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub); // clang-format on // Run the component init @@ -402,8 +413,10 @@ void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, user_credential_slot_t credential_slot) { // WARNING : Order here matters based on their initialization order in the add_complete_credential function - std::vector attribute_names - = {"CredentialData", "CredentialModifierNodeId", "CredentialModifierType"}; + std::vector attribute_names = {"CredentialData", + "AssociationStatus", + "CredentialModifierNodeId", + "CredentialModifierType"}; for (auto &attribute_name: attribute_names) { mqtt_topics.push_back({get_cred_attribute_mqtt_topic(user_id, credential_type, @@ -566,7 +579,8 @@ extern "C" { void helper_test_operation_type(attribute_store_node_t parent_node, user_credential_operation_type_t operation_type, - attribute_store_type_t tested_attribute_type = 0) + attribute_store_type_t tested_attribute_type + = 0) { if (tested_attribute_type == 0) { tested_attribute_type = ATTRIBUTE(USER_OPERATION_TYPE); @@ -742,6 +756,20 @@ attribute_store_node_t credential_data_vector.data(), credential_data_vector.size()); + // Test association status exposure (will not be used anywhere, it is here to test the MQTT exposure) + uint8_t association_status = 0; + mock_expected_cred_mqtt_topic( + user_id, + credential_type, + credential_slot, + "AssociationStatus", + association_status); + attribute_store_emplace(credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &association_status, + sizeof(association_status)); + + // Generated by end device user_credential_modifier_node_id_t modifier_node_id = 1212; user_credential_modifier_type_t modifier_type = ZCL_USER_MODIFIER_TYPE_DNE; @@ -2100,6 +2128,88 @@ void test_user_credential_cluster_learn_stop_happy_case() TEST_ASSERT_EQUAL_MESSAGE(1, stop_flag, "Stop flag should be set to 1"); } +void test_user_credential_cluster_credential_association_happy_case() +{ + user_credential_user_unique_id_t source_user_unique_id = 12; + user_credential_user_unique_id_t destination_user_unique_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t source_credential_slot = 1; + user_credential_slot_t destination_credential_slot = 2; + + helper_add_user_id(source_user_unique_id); + helper_add_complete_credential(source_user_unique_id, + credential_type, + source_credential_slot, + "1234"); + helper_add_user_id(destination_user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + credential_association_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + static_cast(credential_type), + source_user_unique_id, + source_credential_slot, + destination_user_unique_id, + destination_credential_slot), + "Should be able to setup attribute store for credential_association"); + + auto user_id_node + = attribute_store_get_node_child_by_value(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + REPORTED_ATTRIBUTE, + (uint8_t *)&source_user_unique_id, + sizeof(source_user_unique_id), + 0); + auto credential_type_node + = attribute_store_get_node_child_by_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + auto credential_slot_node = attribute_store_get_node_child_by_value( + credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + REPORTED_ATTRIBUTE, + (uint8_t *)&source_credential_slot, + sizeof(source_credential_slot), + 0); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + "User node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + "Credential type node should exists"); + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + "Credential slot should exists"); + + user_credential_user_unique_id_t reported_destination_user_id = 0; + auto association_destination_user_node + = attribute_store_get_node_child_by_type( + credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + 0); + attribute_store_get_desired(association_destination_user_node, + &reported_destination_user_id, + sizeof(reported_destination_user_id)); + TEST_ASSERT_EQUAL_MESSAGE(destination_user_unique_id, + reported_destination_user_id, + "Destination user id mismatch"); + + user_credential_slot_t reported_destination_credential_slot = 0; + auto association_destination_credential_slot_node + = attribute_store_get_node_child_by_type( + credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + 0); + attribute_store_get_desired(association_destination_credential_slot_node, + &reported_destination_credential_slot, + sizeof(reported_destination_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_destination_credential_slot, + "Destination credential slot mismatch"); +} + /////////////////////////////////////////////////// // Support tests /////////////////////////////////////////////////// diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 3e5bba6dc..838ef9ed0 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1212,11 +1212,19 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOU ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) - DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) +// Specific to Credential User Unique Identifier Credential (UUIC) Association +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x29)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) + ///////////////////////////////////////////////// // Z-Wave Plus Info CC DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_ZWAVEPLUS_INFO_VERSION, diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index a64f0bcca..ebf473063 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -508,6 +508,9 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, "User Credential Credential Learn Timeout", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, "User Credential Credential Learn Status", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, "User Credential Credential Learn Steps Remaining", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, "User Credential Association Destination User ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, "User Credential Association Destination Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, "User Credential Association Status", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, // Only one learn can be active at the time, so we make this attribute on the endpoint node {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, "User Credential Credential Learn Stop Flag", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 95edd12e4..a7a9583d6 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -43,6 +43,9 @@ #include #include +// Cpp Attribute store +#include "attribute.hpp" + // UTF16 conversion (deprecated in C++17) // Needed for credential data (password) per specification #include @@ -3063,6 +3066,257 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( sizeof(learn_status)); return status; } + + +///////////////////////////////////////////////////////////////////////////// +// User Unique Identifier Credential Association Set/Report +///////////////////////////////////////////////////////////////////////////// + +static sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t destination_credential_slot_node, + uint8_t *frame, + uint16_t *frame_length) +{ + // Get nodes + auto credential_slot_node = attribute_store_get_first_parent_with_type( + destination_credential_slot_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + auto credential_type_node = attribute_store_get_first_parent_with_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + auto user_id_node = attribute_store_get_first_parent_with_type( + credential_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); + + sl_log_debug(LOG_TAG, "User Unique Identifier Credential Association Set command"); + + // Set the frame + // Since the data is not linear we provide the node directly + std::vector set_data + = {{ATTRIBUTE(USER_UNIQUE_ID), REPORTED_ATTRIBUTE, user_id_node}, + {ATTRIBUTE(CREDENTIAL_TYPE), REPORTED_ATTRIBUTE, credential_type_node}, + {ATTRIBUTE(CREDENTIAL_SLOT), REPORTED_ATTRIBUTE, credential_slot_node}, + {ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), DESIRED_ATTRIBUTE}, + {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), DESIRED_ATTRIBUTE}}; + + sl_status_t status = create_command_frame(USER_CREDENTIAL_ASSOCIATION_SET, + set_data, + credential_slot_node, + frame, + frame_length); + + + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't create User Unique Identifier Credential Association Set frame"); + } + + return status; +} + + +sl_status_t zwave_command_class_user_credential_uuic_association_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) { + + constexpr uint8_t EXPECTED_FRAME_LENGTH = 12; + if (frame_length != EXPECTED_FRAME_LENGTH) { + sl_log_error(LOG_TAG, + "USER_CREDENTIAL_ASSOCIATION_REPORT frame length is not valid. Expected %d, got %d", + EXPECTED_FRAME_LENGTH, + frame_length); + return SL_STATUS_NOT_SUPPORTED; + } + + constexpr uint8_t INDEX_SOURCE_USER_ID = 2; + constexpr uint8_t INDEX_SOURCE_CREDENTIAL_TYPE = 4; + constexpr uint8_t INDEX_SOURCE_CREDENTIAL_SLOT = 5; + constexpr uint8_t INDEX_DESTINATION_USER_ID = 7; + constexpr uint8_t INDEX_DESTINATION_CREDENTIAL_SLOT = 9; + constexpr uint8_t INDEX_ASSOCIATION_STATUS = 11; + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // Interpret frame + const user_credential_user_unique_id_t source_user_id + = get_uint16_value(frame_data, INDEX_SOURCE_USER_ID); + const user_credential_type_t source_credential_type + = frame_data[INDEX_SOURCE_CREDENTIAL_TYPE]; + const user_credential_slot_t source_credential_slot + = get_uint16_value(frame_data, INDEX_SOURCE_CREDENTIAL_SLOT); + const user_credential_user_unique_id_t destination_user_id + = get_uint16_value(frame_data, INDEX_DESTINATION_USER_ID); + const user_credential_slot_t destination_credential_slot + = get_uint16_value(frame_data, INDEX_DESTINATION_CREDENTIAL_SLOT); + const uint8_t association_status = frame_data[INDEX_ASSOCIATION_STATUS]; + + sl_log_debug(LOG_TAG, + "User Unique Identifier Credential Association Report. Source User ID: %d / " + "Source Credential Type: %d / Source Credential Slot: %d / " + "Destination User ID: %d / Destination Credential Slot: %d", + source_user_id, + source_credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot); + + // Get nodes + attribute_store_node_t source_credential_type_node; + attribute_store_node_t source_credential_slot_node; + get_credential_type_node(endpoint_node, + source_user_id, + source_credential_type, + REPORTED_ATTRIBUTE, + source_credential_type_node); + get_credential_slot_node(source_credential_type_node, + source_credential_slot, + REPORTED_ATTRIBUTE, + source_credential_slot_node); + + if (!attribute_store_node_exists(source_credential_type_node) + || !attribute_store_node_exists(source_credential_slot_node)) { + sl_log_error(LOG_TAG, + "Can't find User %d, Credential Type %d, " + "Credential Slot %d reported by User Unique Identifier Credential Association Report", + source_user_id, + source_credential_type, + source_credential_slot); + return SL_STATUS_NOT_SUPPORTED; + } + + // Set association status + attribute_store_set_child_reported(source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &association_status, + sizeof(association_status)); + + // Clean up association data so ZPC won't try to send the SET command again + auto association_destination_user_id_node = attribute_store_get_first_child_by_type( + source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)); + auto association_destination_credential_slot_node + = attribute_store_get_first_child_by_type( + source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)); + attribute_store_delete_node(association_destination_user_id_node); + attribute_store_delete_node(association_destination_credential_slot_node); + + if (association_status != USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS) { + sl_log_error(LOG_TAG, + "User Unique Identifier Credential Association error. " + "Reported status code : %d", + association_status); + return SL_STATUS_OK; + } + + // Simple case : we only have to change the slot number + if (destination_user_id == source_user_id) { + sl_log_info(LOG_TAG, + "Moving slot %d to slot %d (user %d)", + source_credential_slot, + destination_credential_slot, + destination_user_id); + + return attribute_store_set_reported( + source_credential_slot_node, + &destination_credential_slot, + sizeof(destination_credential_slot)); + } + + // Complex case : we have to move the slot to another user + sl_log_info(LOG_TAG, + "Moving slot %d (user %d) to slot %d (user %d)", + source_credential_slot, + source_user_id, + destination_credential_slot, + destination_user_id); + + // Get user node + attribute_store_node_t destination_user_id_node; + get_user_id_node(endpoint_node, + destination_user_id, + REPORTED_ATTRIBUTE, + destination_user_id_node); + + if (!attribute_store_node_exists(destination_user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find User %d reported by User Unique Identifier Credential Association Report", + destination_user_id); + return SL_STATUS_NOT_SUPPORTED; + } + + // Get destination type node + attribute_store_node_t destination_credential_type_node; + // Look for it if it exists + get_credential_type_node(endpoint_node, + destination_user_id, + source_credential_type, + REPORTED_ATTRIBUTE, + destination_credential_type_node); + // If it doesn't exists yet we create it + if (!attribute_store_node_exists(destination_credential_type_node)) { + destination_credential_type_node + = attribute_store_emplace(destination_user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &source_credential_type, + sizeof(source_credential_type)); + } + + // Get destination slot node (if we are here we assume that it doesn't exists) + attribute_store_node_t destination_credential_slot_node + = attribute_store_emplace(destination_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &destination_credential_slot, + sizeof(destination_credential_slot)); + + // Copy attribute tree + attribute_store::attribute cpp_source_credential_slot_node( + source_credential_slot_node); + attribute_store::attribute cpp_destination_credential_slot_node( + destination_credential_slot_node); + + // Can't use walk_tree here since we need a capturing lambda + // Define the lambda explicitly since it is recursive https://stackoverflow.com/a/4081391 + std::function + deep_copy_reported_attributes; + deep_copy_reported_attributes = + [&](attribute_store::attribute cpp_current_node, + attribute_store::attribute cpp_parent_node) { + // Ignore fields that doesn't have a reported value + if (!cpp_current_node.reported_exists()) { + return; + } + attribute_store_node_t destination_node; + // If we are not at the root node, add new node + if (cpp_current_node.type() != cpp_parent_node.type()) { + destination_node + = attribute_store_add_node(cpp_current_node.type(), cpp_parent_node); + + attribute_store_copy_value(cpp_current_node, + destination_node, + REPORTED_ATTRIBUTE); + } + // Check node children + for (auto child: cpp_current_node.children()) { + // If we are not at the root, need to copy the child attribute + if (cpp_current_node.type() != cpp_parent_node.type()) { + cpp_parent_node = destination_node; + } + deep_copy_reported_attributes(child, cpp_parent_node); + } + }; + deep_copy_reported_attributes(cpp_source_credential_slot_node, + cpp_destination_credential_slot_node); + + // Then remove the old node + attribute_store_delete_node(source_credential_slot_node); + + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // User Set/Get/Report/Set Error Report ///////////////////////////////////////////////////////////////////////////// @@ -4361,6 +4615,72 @@ sl_status_t zwave_command_class_user_credential_credential_learn_stop( sizeof(stop_flag)); } + +sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_user_unique_id_t source_user_id, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot) +{ + attribute_store_node_t source_user_id_node; + bool user_exists = get_user_id_node(endpoint_node, + source_user_id, + REPORTED_ATTRIBUTE, + source_user_id_node); + if (!user_exists) { + sl_log_error(LOG_TAG, + "Can't find source user with ID %d. Not adding uuic association set.", + source_user_id); + return SL_STATUS_FAIL; + } + + attribute_store_node_t credential_type_node; + bool cred_type_exists = get_credential_type_node(endpoint_node, + source_user_id, + credential_type, + REPORTED_ATTRIBUTE, + credential_type_node); + + if (!cred_type_exists) { + sl_log_error(LOG_TAG, + "Can't find credential type %d for user %d. Not adding uuic association set.", + credential_type, + source_user_id); + return SL_STATUS_FAIL; + } + + attribute_store_node_t source_credential_slot_node; + bool cred_slot_exists = get_credential_slot_node(credential_type_node, + source_credential_slot, + REPORTED_ATTRIBUTE, + source_credential_slot_node); + + if (!cred_slot_exists) { + sl_log_error(LOG_TAG, + "Can't find source credential slot %d for credential type %d. Not adding uuic association set.", + source_credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + attribute_store_emplace_desired(source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + &destination_user_id, + sizeof(destination_user_id)); + + // Slot ID last since it's this attribute that is bound to the SET command + attribute_store_emplace_desired( + source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + &destination_credential_slot, + sizeof(destination_credential_slot)); + + return SL_STATUS_OK; +} + + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// @@ -4416,11 +4736,17 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case USER_CREDENTIAL_ASSOCIATION_REPORT: + return zwave_command_class_user_credential_uuic_association_report( + connection_info, + frame_data, + frame_length); default: return SL_STATUS_NOT_SUPPORTED; } } + // Entry point sl_status_t zwave_command_class_user_credential_init() { @@ -4473,6 +4799,11 @@ sl_status_t zwave_command_class_user_credential_init() &zwave_command_class_user_credential_credential_learn_cancel, NULL); + attribute_resolver_register_rule( + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + &zwave_command_class_user_credential_uuic_association_set, + NULL); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 3edfb0715..6aacf1818 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -297,6 +297,28 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( sl_status_t zwave_command_class_user_credential_credential_learn_stop( attribute_store_node_t endpoint_node); + +/** + * @brief Send a User Unique Identifier Credential Association Set to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. + * @param source_user_id The unique ID of the source user. Should exists. Cannot be 0. + * @param source_credential_slot The slot of the source credential. Should exists. Cannot be 0. + * @param destination_user_id The unique ID of the destination user. Cannot be 0. + * @param destination_credential_slot The slot of the destination credential. Should not exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_user_unique_id_t source_user_id, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 4892d3a7e..c32a9bda4 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -59,16 +59,19 @@ struct bound_functions { uint8_t get_func_id; uint8_t set_func_id; }; -static std::map attributes_binding - = {{ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, - {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, - {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, - {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, - {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}, - {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), {0, CREDENTIAL_LEARN_START}}, - {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}}; +static std::map attributes_binding = { + {ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, + {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, + {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, + {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}, + {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), {0, CREDENTIAL_LEARN_START}}, + {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}, + {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + {0, USER_CREDENTIAL_ASSOCIATION_SET}}, +}; // Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on // attributes_binding map. @@ -382,6 +385,47 @@ void helper_create_learn_status_report_frame( handler.control_handler(&info, report_frame.data(), report_frame.size())); } +void helper_association_report_frame( + user_credential_user_unique_id_t source_user_id, + user_credential_type_t source_credential_type, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot, + uint8_t credential_association_status) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, USER_CREDENTIAL_ASSOCIATION_REPORT}; + + auto exploded_user_id = explode_uint16(source_user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(source_credential_type); + + auto exploded_credential_slot = explode_uint16(source_credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + exploded_user_id = explode_uint16(destination_user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + exploded_credential_slot = explode_uint16(destination_credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(credential_association_status); + + // Do the report + TEST_ASSERT_EQUAL( + SL_STATUS_OK, + handler.control_handler(&info, report_frame.data(), report_frame.size())); +} /** * @brief Create credential structure and return associated nodes * @@ -685,7 +729,7 @@ void helper_test_credential_learn_structure( &credential_slot, sizeof(credential_slot)); - uint8_t step_remaining = 2; + uint8_t step_remaining = 2; user_credential_learn_status_t learn_status = CREDENTIAL_LEARN_REPORT_SUCCESS; helper_create_learn_status_report_frame(learn_status, user_id, @@ -701,6 +745,92 @@ void helper_test_credential_learn_structure( helper_test_attribute_store_values(uint8_attribute_map, credential_slot_node); }; +struct association_nodes_t { + attribute_store_node_t association_user_id_node; + attribute_store_node_t association_credential_slot_node; +}; +association_nodes_t + helper_setup_association(attribute_store_node_t credential_slot_node, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot) +{ + association_nodes_t association_nodes; + + association_nodes.association_user_id_node = attribute_store_emplace_desired( + credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + &destination_user_id, + sizeof(destination_user_id)); + association_nodes.association_credential_slot_node + = attribute_store_emplace_desired( + credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + &destination_credential_slot, + sizeof(destination_credential_slot)); + + return association_nodes; +} + +void helper_fill_credential_data(attribute_store_node_t credential_slot_node, + std::string credential_data, + user_credential_modifier_type_t modifier_type) +{ + uint8_t credential_data_length = credential_data.size(); + auto credential_data_length_node + = attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH), + &credential_data_length, + sizeof(uint8_t)); + + attribute_store_emplace(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + credential_data.data(), + credential_data.size()); + + attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + &modifier_type, + sizeof(modifier_type)); +} +void helper_test_credential_data(attribute_store_node_t credential_slot_node, + std::string credential_data, + user_credential_modifier_type_t modifier_type) +{ + uint8_t credential_data_length = credential_data.size(); + auto credential_data_length_node = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + uint8_t reported_credential_data_length; + attribute_store_get_reported(credential_data_length_node, + &reported_credential_data_length, + sizeof(reported_credential_data_length)); + TEST_ASSERT_EQUAL_MESSAGE(credential_data_length, + reported_credential_data_length, + "Credential data length mismatch"); + + std::vector reported_credential_data; + reported_credential_data.resize(reported_credential_data_length); + + attribute_store_get_child_reported(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA), + reported_credential_data.data(), + reported_credential_data_length); + + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(credential_data.data(), + reported_credential_data.data(), + credential_data.size(), + "Credential data mismatch"); + + user_credential_modifier_type_t reported_modifier_type; + attribute_store_get_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + &reported_modifier_type, + sizeof(reported_modifier_type)); + TEST_ASSERT_EQUAL_MESSAGE(modifier_type, + reported_modifier_type, + "Modifier type mismatch"); +} + ///////////////////////////////////////////////////// // Test case ///////////////////////////////////////////////////// @@ -2574,9 +2704,11 @@ void test_user_credential_add_credential_invalid_slot() credential_slot, credential_data.c_str()); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, - status, - "Credential add should have returned SL_STATUS_FAIL (trying to add a non supported slot)"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + status, + "Credential add should have returned SL_STATUS_FAIL (trying to add a non " + "supported slot)"); } void test_user_credential_user_notification_add_modify_delete_happy_case() @@ -4578,7 +4710,8 @@ void test_user_credential_credential_learn_start_modify_credential_not_existing( "Should not be able to start learning (modify)"); } -void test_user_credential_credential_learn_cancel_happy_case() { +void test_user_credential_credential_learn_cancel_happy_case() +{ uint8_t stop_flag = 0; auto stop_node = attribute_store_emplace_desired(endpoint_id_node, @@ -4592,9 +4725,10 @@ void test_user_credential_credential_learn_cancel_happy_case() { TEST_ASSERT_NOT_NULL_MESSAGE( get_func, "Couldn't find get function in resolver_functions."); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - get_func(stop_node, received_frame, &received_frame_size), - "Get function should have returned OK"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_func(stop_node, received_frame, &received_frame_size), + "Get function should have returned OK"); attribute_store_get_reported(stop_node, &stop_flag, sizeof(stop_flag)); TEST_ASSERT_EQUAL_MESSAGE(1, @@ -4602,4 +4736,495 @@ void test_user_credential_credential_learn_cancel_happy_case() { "Stop flag should have been set to 1"); } +void test_user_credential_uuic_association_same_slot_different_user() +{ + // Capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {5, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Structure + user_credential_user_unique_id_t source_user_id = 12; + user_credential_user_unique_id_t destination_user_id = 15; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t source_credential_slot = 1; + user_credential_slot_t destination_credential_slot = 1; + // Credential data + std::string credential_data = "123456"; + user_credential_modifier_type_t modifier_type = 5; + uint8_t association_status = USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS; + + auto source_nodes = helper_create_credential_structure(source_user_id, + credential_type, + source_credential_slot, + REPORTED_ATTRIBUTE); + + auto destination_user_id_node + = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &destination_user_id, + sizeof(destination_user_id)); + + helper_fill_credential_data(source_nodes.credential_slot_node, + credential_data, + modifier_type); + auto association_nodes + = helper_setup_association(source_nodes.credential_slot_node, + destination_user_id, + destination_credential_slot); + // Simulate Set + helper_test_set_get_with_args( + USER_CREDENTIAL_ASSOCIATION_SET, + association_nodes.association_credential_slot_node, + {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, + {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, + {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + + // Then simulate report + helper_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); + + // Test data structure + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_type_node), + "Old credential type node should still exist"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_slot_node), + "Old credential slot node should have been removed"); + // Association nodes doesn't have any reported value so they shouldn't exists anymore + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(association_nodes.association_user_id_node), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists( + association_nodes.association_credential_slot_node), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 0, + attribute_store_get_node_child_count(source_nodes.credential_type_node), + "Source Credential type node should have no children"); + + // Check destination structure + auto destination_credential_type_node + = attribute_store_get_first_child_by_type(destination_user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + user_credential_type_t reported_credential_type; + attribute_store_get_reported(destination_credential_type_node, + &reported_credential_type, + sizeof(reported_credential_type)); + TEST_ASSERT_EQUAL_MESSAGE(credential_type, + reported_credential_type, + "Credential type mismatch"); + + auto destination_credential_slot_node + = attribute_store_get_first_child_by_type(destination_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + user_credential_slot_t reported_credential_slot; + attribute_store_get_reported(destination_credential_slot_node, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_credential_slot, + "Credential slot mismatch"); + + helper_test_credential_data(destination_credential_slot_node, + credential_data, + modifier_type); + uint8_t reported_status; + attribute_store_get_child_reported(destination_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &reported_status, + sizeof(reported_status)); + TEST_ASSERT_EQUAL_MESSAGE(association_status, + reported_status, + "Association status mismatch"); +} + +void test_user_credential_uuic_association_different_slot_different_user_with_existing_type() +{ + // Capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {5, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Structure + user_credential_user_unique_id_t source_user_id = 12; + user_credential_user_unique_id_t destination_user_id = 15; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t source_credential_slot = 1; + user_credential_slot_t destination_credential_slot = 2; + // Credential data + std::string credential_data = "123456"; + user_credential_modifier_type_t modifier_type = 5; + uint8_t association_status = USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS; + + auto source_nodes = helper_create_credential_structure(source_user_id, + credential_type, + source_credential_slot, + REPORTED_ATTRIBUTE); + + auto destination_user_id_node + = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &destination_user_id, + sizeof(destination_user_id)); + // Already present type + attribute_store_emplace(destination_user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + helper_fill_credential_data(source_nodes.credential_slot_node, + credential_data, + modifier_type); + auto association_nodes + = helper_setup_association(source_nodes.credential_slot_node, + destination_user_id, + destination_credential_slot); + // Simulate Set + helper_test_set_get_with_args( + USER_CREDENTIAL_ASSOCIATION_SET, + association_nodes.association_credential_slot_node, + {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, + {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, + {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + + // Then simulate report + helper_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); + + // Test data structure + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_type_node), + "Old credential type node should still exist"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_slot_node), + "Old credential slot node should have been removed"); + // Association nodes doesn't have any reported value so they shouldn't exists anymore + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(association_nodes.association_user_id_node), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists( + association_nodes.association_credential_slot_node), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 0, + attribute_store_get_node_child_count(source_nodes.credential_type_node), + "Source Credential type node should have no children"); + + // Check destination structure + auto destination_credential_type_node + = attribute_store_get_first_child_by_type(destination_user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + user_credential_type_t reported_credential_type; + attribute_store_get_reported(destination_credential_type_node, + &reported_credential_type, + sizeof(reported_credential_type)); + TEST_ASSERT_EQUAL_MESSAGE(credential_type, + reported_credential_type, + "Credential type mismatch"); + + auto destination_credential_slot_node + = attribute_store_get_first_child_by_type(destination_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + user_credential_slot_t reported_credential_slot; + attribute_store_get_reported(destination_credential_slot_node, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_credential_slot, + "Credential slot mismatch"); + + helper_test_credential_data(destination_credential_slot_node, + credential_data, + modifier_type); + uint8_t reported_status; + attribute_store_get_child_reported(destination_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &reported_status, + sizeof(reported_status)); + TEST_ASSERT_EQUAL_MESSAGE(association_status, + reported_status, + "Association status mismatch"); +} + +void test_user_credential_uuic_association_different_slot_same_user() +{ + // Capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {5, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Structure + user_credential_user_unique_id_t source_user_id = 12; + user_credential_user_unique_id_t destination_user_id = 12; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t source_credential_slot = 1; + user_credential_slot_t destination_credential_slot = 2; + // Credential data + std::string credential_data = "123456"; + user_credential_modifier_type_t modifier_type = 5; + uint8_t association_status = USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS; + + auto source_nodes = helper_create_credential_structure(source_user_id, + credential_type, + source_credential_slot, + REPORTED_ATTRIBUTE); + + helper_fill_credential_data(source_nodes.credential_slot_node, + credential_data, + modifier_type); + auto association_nodes + = helper_setup_association(source_nodes.credential_slot_node, + destination_user_id, + destination_credential_slot); + // Simulate Set + helper_test_set_get_with_args( + USER_CREDENTIAL_ASSOCIATION_SET, + association_nodes.association_credential_slot_node, + {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, + {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, + {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + + // Then simulate report + helper_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); + + // Test data structure + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_type_node), + "Old credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_slot_node), + "Old credential slot node should just been updated"); + // Association nodes doesn't have any reported value so they shouldn't exists anymore + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(association_nodes.association_user_id_node), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists( + association_nodes.association_credential_slot_node), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 1, + attribute_store_get_node_child_count(source_nodes.credential_type_node), + "Source Credential type node should have one children"); + + // Check destination structure + auto destination_credential_type_node = source_nodes.credential_type_node; + user_credential_type_t reported_credential_type; + attribute_store_get_reported(destination_credential_type_node, + &reported_credential_type, + sizeof(reported_credential_type)); + TEST_ASSERT_EQUAL_MESSAGE(credential_type, + reported_credential_type, + "Credential type mismatch"); + + auto destination_credential_slot_node + = attribute_store_get_first_child_by_type(destination_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + user_credential_slot_t reported_credential_slot; + attribute_store_get_reported(destination_credential_slot_node, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_credential_slot, + "Credential slot mismatch"); + + helper_test_credential_data(destination_credential_slot_node, + credential_data, + modifier_type); + uint8_t reported_status; + attribute_store_get_child_reported(destination_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &reported_status, + sizeof(reported_status)); + TEST_ASSERT_EQUAL_MESSAGE(association_status, + reported_status, + "Association status mismatch"); +} + +void test_user_credential_uuic_association_error_code() +{ + // Capabilities + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector supported_cl = {1, 1}; + std::vector supported_credential_slots = {5, 2}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cl_timeout = {20, 2}; + std::vector supported_cl_steps = {1, 95}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + supported_cl_timeout, + supported_cl_steps); + + // Structure + user_credential_user_unique_id_t source_user_id = 12; + user_credential_user_unique_id_t destination_user_id = 15; + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + user_credential_slot_t source_credential_slot = 1; + user_credential_slot_t destination_credential_slot = 1; + // Credential data + std::string credential_data = "123456"; + user_credential_modifier_type_t modifier_type = 5; + uint8_t association_status = USER_CREDENTIAL_ASSOCIATION_REPORT_SOURCE_CREDENTIAL_SLOT_EMPTY; + + auto source_nodes = helper_create_credential_structure(source_user_id, + credential_type, + source_credential_slot, + REPORTED_ATTRIBUTE); + + auto destination_user_id_node + = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &destination_user_id, + sizeof(destination_user_id)); + + helper_fill_credential_data(source_nodes.credential_slot_node, + credential_data, + modifier_type); + auto association_nodes + = helper_setup_association(source_nodes.credential_slot_node, + destination_user_id, + destination_credential_slot); + // Simulate Set + helper_test_set_get_with_args( + USER_CREDENTIAL_ASSOCIATION_SET, + association_nodes.association_credential_slot_node, + {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, + {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, + {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, + {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + + // Then simulate report + helper_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); + + // Test data structure + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_type_node), + "Old credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(source_nodes.credential_slot_node), + "Old credential slot node should have been removed"); + // Association nodes doesn't have any reported value so they shouldn't exists anymore + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(association_nodes.association_user_id_node), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists( + association_nodes.association_credential_slot_node), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 1, + attribute_store_get_node_child_count(source_nodes.credential_type_node), + "Source Credential type node should have one children"); + + // No move should have been performed + TEST_ASSERT_EQUAL_MESSAGE( + 0, + attribute_store_get_node_child_count(destination_user_id_node), + "Nothing should have changed for destination user ID node"); + + // Test source credential slot node + auto destination_credential_slot_node = source_nodes.credential_slot_node; + user_credential_slot_t reported_credential_slot; + attribute_store_get_reported(destination_credential_slot_node, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_credential_slot, + "Credential slot mismatch"); + + helper_test_credential_data(destination_credential_slot_node, + credential_data, + modifier_type); + uint8_t reported_status; + attribute_store_get_child_reported(destination_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &reported_status, + sizeof(reported_status)); + TEST_ASSERT_EQUAL_MESSAGE(association_status, + reported_status, + "Association status mismatch"); +} + + } // extern "C" \ No newline at end of file From 8088874c3ffb2c3152ff980f10133cbc90146962 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 4 Jun 2024 12:18:12 +0200 Subject: [PATCH 18/60] UIC-3222: User Checksum Get/Report UIC-3222: Update User Checksum Get --- .../src/user_credential_cluster_server.cpp | 30 +- .../user_credential_cluster_server_test.cpp | 86 ++- .../attribute_store_defined_attribute_types.h | 6 + ...wave_command_class_user_credential_types.h | 2 + .../zpc_attribute_store_type_registration.cpp | 7 +- .../zwave_command_class_user_credential.cpp | 655 +++++++++++++----- .../src/zwave_command_class_user_credential.h | 13 + ...ave_command_class_user_credential_test.cpp | 282 ++++++++ 8 files changed, 898 insertions(+), 183 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 2b561067c..efe4f28c6 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -91,6 +91,8 @@ static const user_attributes_mqtt_map_t user_attributes = { {"UserModifierType", user_modifier_type_get_enum_value_name}}, {ATTRIBUTE(USER_MODIFIER_NODE_ID), {"UserModifierNodeId"}}, {ATTRIBUTE(USER_NAME), {"UserName"}}, + {ATTRIBUTE(USER_CHECKSUM), {"UserChecksum"}}, + {ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), {"UserChecksumError"}}, }; // Credential attributes @@ -542,6 +544,30 @@ sl_status_t uuic_association_set(dotdot_unid_t unid, destination_credential_slot); } +sl_status_t get_user_checksum(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + uint16_t user_uniqueid) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + + } + + return zwave_command_class_user_credential_get_user_checksum(endpoint_node, + user_uniqueid); +} + /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -967,6 +993,8 @@ sl_status_t user_credential_cluster_server_init() // UUIC association uic_mqtt_dotdot_user_credential_credential_association_callback_set( &uuic_association_set); - + // User Checksum + uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set( + &get_user_checksum); return SL_STATUS_OK; } diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 3838d17a4..8e810da84 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -83,6 +83,7 @@ uic_mqtt_dotdot_user_credential_credential_learn_start_add_callback_t credential uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t credential_learn_start_modify_command = NULL; uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t credential_learn_stop_command = NULL; uic_mqtt_dotdot_user_credential_credential_association_callback_t credential_association_command = NULL; +uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_user_checksum_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -192,6 +193,13 @@ void uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub( credential_association_command = callback; } +void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub( + const uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t callback, + int cmock_num_calls) +{ + get_user_checksum_command = callback; +} + /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() { @@ -271,6 +279,8 @@ void setUp() uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_set_stub); // UUIC association uic_mqtt_dotdot_user_credential_credential_association_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub); + // User checksum + uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub); // clang-format on // Run the component init @@ -397,7 +407,9 @@ void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id) "UserNameEncoding", "UserName", "UserModifierNodeId", - "UserModifierType"}; + "UserModifierType", + "UserChecksum", + "UserChecksumError"}; for (auto &attribute_name: attribute_names) { mqtt_topics.push_back( {get_user_attribute_mqtt_topic(user_id, attribute_name), ""}); @@ -692,6 +704,26 @@ attribute_store_node_t helper_add_complete_user( &modifier_type, sizeof(modifier_type)); + // Only used to see if they are correctly exposed + user_credential_checksum_t user_checksum = 0xABCD; + mock_expected_user_mqtt_topic( + user_id, + "UserChecksum", + user_checksum); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_CHECKSUM), + &user_checksum, + sizeof(user_checksum)); + user_credential_checksum_t computed_checksum = 0xFFFF; + mock_expected_user_mqtt_topic( + user_id, + "UserChecksumError", + computed_checksum); + attribute_store_emplace(user_id_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + &computed_checksum, + sizeof(computed_checksum)); + // Cleanup : this will automatically test the MQTT deletion messages created_user_id.push_back(user_id); @@ -2210,6 +2242,58 @@ void test_user_credential_cluster_credential_association_happy_case() "Destination credential slot mismatch"); } +void test_user_credential_cluster_test_user_checksum_happy_case() +{ + user_credential_user_unique_id_t user_unique_id = 12; + + auto user_id_node = helper_add_user_id(user_unique_id); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_user_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id), + "Should be able to setup attribute store for get_user_checksum"); + + auto checksum_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_CHECKSUM)); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(checksum_node), + "Checksum node should exists"); + user_credential_checksum_t checksum = 1312; + mock_expected_user_mqtt_topic(user_unique_id, + "UserChecksum", + checksum); + attribute_store_set_reported(checksum_node, &checksum, sizeof(checksum)); + + // Try a second time to see if we still have only one checksum node + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_user_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + user_unique_id), + "Should be able to setup attribute store for get_user_checksum"); + + auto checksum_count + = attribute_store_get_node_child_count_by_type(user_id_node, + ATTRIBUTE(USER_CHECKSUM)); + + TEST_ASSERT_EQUAL_MESSAGE(1, + checksum_count, + "Should have only one checksum attribute"); + + checksum_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_CHECKSUM)); + + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_is_reported_defined(checksum_node), + "Checksum node reported value should be not defined"); +} + /////////////////////////////////////////////////// // Support tests /////////////////////////////////////////////////// diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 838ef9ed0..2c8b9c0dc 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1225,6 +1225,12 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) +// Checksums +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) + ///////////////////////////////////////////////// // Z-Wave Plus Info CC DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_ZWAVEPLUS_INFO_VERSION, diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index 7d9381bef..218c17207 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -40,6 +40,8 @@ typedef uint8_t user_credential_modifier_type_t; ///> User Modifier Node ID. uint16_t typedef uint16_t user_credential_modifier_node_id_t; +///> User Credential Checksum. uint16_t +typedef uint16_t user_credential_checksum_t; ///> User Type. uint8_t #define USER_CREDENTIAL_USER_TYPE_GENERAL_USER 0x00 diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index ebf473063..5ca597c78 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -479,7 +479,8 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, "User Credential Max Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, "User Credential Learn Recommended Timeout", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, "User Credential Learn Number Of Steps", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, - + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, "User Credential Credential Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM_MISMATCH_ERROR, "User Credential Credential Checksum Mismatch Error (computed by zpc)", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, // All Users Checksum {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ALL_USERS_CHECKSUM, "User Credential All User Checksum", ATTRIBUTE_ENDPOINT_ID, U16_STORAGE_TYPE}, @@ -495,6 +496,8 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, "User Credential User Credential Rule", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, "User Credential User Operation type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, "User Credential User Expiring Timeout Minutes", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, "User Credential User Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, "User Credential User Checksum Mismatch Error (computed by zpc)", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U16_STORAGE_TYPE}, // Credential {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, "User Credential Credential Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, @@ -511,6 +514,8 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, "User Credential Association Destination User ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, "User Credential Association Destination Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, "User Credential Association Status", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, + // Credential Checksum is under the Credential Type not Credential Slot + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, "User Credential Credential Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, // Only one learn can be active at the time, so we make this attribute on the endpoint node {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, "User Credential Credential Learn Stop Flag", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index a7a9583d6..a56ae0d8c 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -27,6 +27,7 @@ #include "zwave_command_class_version_types.h" #include "attribute_store_defined_attribute_types.h" #include "zpc_attribute_store.h" +#include "zwave_controller_crc16.h" // Unify #include "attribute_resolver.h" @@ -58,7 +59,8 @@ // If the user name has a size > to this number, we will truncate it // Specification says that payload data should not exceeded 64 bytes. #define MAX_CHAR_SIZE 64 - +// Used to compute checksums +#define CRC_INITIALIZATION_VALUE 0x1D0F /** * @brief Implementation notes * @@ -850,6 +852,147 @@ sl_status_t return status; } +/** + * @brief Get value inside the node and store it in a uint8_t vector + * + * @param node Node to get the value from + * @param data Vector to store the value (output). It will be cleared before any data is stored in it + * @param value_state Value state (reported, desired,...). Default to Reported + * + * @return sl_status_t SL_STATUS_OK if everything was fine + * @return SL_STATUS_NOT_SUPPORTED If the storage type is not supported or other errors +*/ +sl_status_t node_to_uint8_vector(attribute_store_node_t node, + std::vector &data, + attribute_store_node_value_state_t value_state + = REPORTED_ATTRIBUTE) +{ + data.clear(); + + auto node_type = attribute_store_get_node_type(node); + auto node_storage_type = attribute_store_get_storage_type(node_type); + auto attribute_description = attribute_store_get_type_name(node_type); + + sl_status_t status; + switch (node_storage_type) { + case U8_STORAGE_TYPE: { + uint8_t uint8_value; + status = attribute_store_read_value(node, + value_state, + &uint8_value, + sizeof(uint8_value)); + data.push_back(uint8_value); + } break; + case U16_STORAGE_TYPE: { + uint16_t uint16_value; + status = attribute_store_read_value(node, + value_state, + &uint16_value, + sizeof(uint16_value)); + auto exploded_uint16 = explode_uint16(uint16_value); + data.push_back(exploded_uint16.msb); + data.push_back(exploded_uint16.lsb); + } break; + // Variable length field + case BYTE_ARRAY_STORAGE_TYPE: { + // First get the length + auto credential_length_node = attribute_store_get_node_parent(node); + + uint8_t credential_data_length = 0; + status = attribute_store_read_value(credential_length_node, + value_state, + &credential_data_length, + sizeof(credential_data_length)); + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Missing BYTE_ARRAY_STORAGE_TYPE length for attribute %s", + attribute_description); + return SL_STATUS_NOT_SUPPORTED; + } + // + 1 for the length + data.resize(credential_data_length + 1); + data[0] = credential_data_length; + status + = attribute_store_read_value(node, + value_state, + data.data() + 1, // Offset for the length + credential_data_length); + } break; + + case C_STRING_STORAGE_TYPE: { + char c_user_name[MAX_CHAR_SIZE]; + // Unfortunately attribute_store_get_string is not exposed so we need to do this + switch (value_state) { + case DESIRED_OR_REPORTED_ATTRIBUTE: + status + = attribute_store_get_desired_else_reported_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + case DESIRED_ATTRIBUTE: + status = attribute_store_get_desired_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + case REPORTED_ATTRIBUTE: + status = attribute_store_get_reported_string(node, + c_user_name, + MAX_CHAR_SIZE); + break; + } + + std::string user_name = c_user_name; + data.push_back(user_name.length()); + for (const char &c: user_name) { + data.push_back(c); + } + } break; + default: + sl_log_critical(LOG_TAG, + "Not supported type for %s", + attribute_description); + return SL_STATUS_FAIL; + } + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Can't get value of Attribute %s", + attribute_description); + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + +/** + * @brief Compute a node value and add it to the current checksum + * + * @param current_checksum Current checksum (can be empty) + * @param node Node to compute the checksum from + * + * @return true If the node was added to the checksum + * @return false If the node was not added to the checksum +*/ +bool add_node_to_checksum(std::vector ¤t_checksum, + attribute_store_node_t node) +{ + if (!attribute_store_node_exists(node)) { + sl_log_error(LOG_TAG, "Can't find node %d. Not adding to checksum.", node); + return false; + } + std::vector data; + if (node_to_uint8_vector(node, data) != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't convert node %d to uint8_t vector. Not adding to checksum.", + node); + return false; + } + current_checksum.insert(current_checksum.end(), data.begin(), data.end()); + + return true; +}; /** * @brief Create a command frame (SET or GET) based on the attribute store * @@ -874,8 +1017,6 @@ sl_status_t uint16_t current_index = 2; for (auto &attribute_info: command_data) { - auto node_storage_type - = attribute_store_get_storage_type(attribute_info.attribute_type); auto attribute_description = attribute_store_get_type_name(attribute_info.attribute_type); @@ -895,102 +1036,14 @@ sl_status_t return SL_STATUS_FAIL; } - sl_status_t status; - switch (node_storage_type) { - case U8_STORAGE_TYPE: { - uint8_t uint8_value; - status = attribute_store_read_value(node, - attribute_info.attribute_state, - &uint8_value, - sizeof(uint8_value)); - frame[current_index++] = uint8_value; - } break; - case U16_STORAGE_TYPE: { - uint16_t uint16_value; - status = attribute_store_read_value(node, - attribute_info.attribute_state, - &uint16_value, - sizeof(uint16_value)); - auto exploded_uint16 = explode_uint16(uint16_value); - frame[current_index++] = exploded_uint16.msb; - frame[current_index++] = exploded_uint16.lsb; - } break; - // Variable length field - case BYTE_ARRAY_STORAGE_TYPE: { - // First get the length - auto credential_length_node = attribute_store_get_node_parent(node); - - uint8_t credential_data_length = 0; - status = attribute_store_read_value(credential_length_node, - attribute_info.attribute_state, - &credential_data_length, - sizeof(credential_data_length)); - - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Missing BYTE_ARRAY_STORAGE_TYPE length for attribute %s", - attribute_description); - return SL_STATUS_NOT_SUPPORTED; - } - - frame[current_index++] = credential_data_length; - - // Then the data - std::vector credential_data; - credential_data.resize(credential_data_length); - status = attribute_store_read_value(node, - attribute_info.attribute_state, - credential_data.data(), - credential_data_length); - - for (const uint8_t &cred: credential_data) { - frame[current_index++] = cred; - } - - } break; - - case C_STRING_STORAGE_TYPE: { - char c_user_name[MAX_CHAR_SIZE]; - // Unfortunately attribute_store_get_string is not exposed so we need to do this - switch (attribute_info.attribute_state) { - case DESIRED_OR_REPORTED_ATTRIBUTE: - status - = attribute_store_get_desired_else_reported_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - case DESIRED_ATTRIBUTE: - status = attribute_store_get_desired_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - case REPORTED_ATTRIBUTE: - status = attribute_store_get_reported_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - } - - std::string user_name = c_user_name; - frame[current_index++] = user_name.length(); - for (const char &c: user_name) { - frame[current_index++] = c; - } - - } break; - default: - sl_log_critical(LOG_TAG, - "Not supported type for %s", - attribute_description); - return SL_STATUS_FAIL; - } - + std::vector data; + sl_status_t status + = node_to_uint8_vector(node, data, attribute_info.attribute_state); if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get value of Attribute %s", - attribute_description); - return SL_STATUS_NOT_SUPPORTED; + return status; + } + for (auto &byte: data) { + frame[current_index++] = byte; } } @@ -1154,10 +1207,11 @@ void update_user_reported_values(attribute_store_node_t user_id_node, bool is_report_size_conform(uint8_t event_parameters_length) { if (event_parameters_length != USER_NOTIFICATION_REPORT_FRAME_LENGTH) { - sl_log_error(LOG_TAG, - "Invalid User Notification Report size got %d, expected %d", - event_parameters_length, - USER_NOTIFICATION_REPORT_FRAME_LENGTH); + sl_log_error( + LOG_TAG, + "Invalid User Notification Report size got %0xd, expected %0xd", + event_parameters_length, + USER_NOTIFICATION_REPORT_FRAME_LENGTH); return false; } return true; @@ -2874,7 +2928,8 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( constexpr uint8_t EXPECTED_FRAME_LENGTH = 9; if (frame_length != EXPECTED_FRAME_LENGTH) { sl_log_error(LOG_TAG, - "CREDENTIAL_LEARN_STATUS_REPORT frame length is not valid. Expected %d, got %d", + "CREDENTIAL_LEARN_STATUS_REPORT frame length is not valid. " + "Expected %d, got %d", EXPECTED_FRAME_LENGTH, frame_length); return SL_STATUS_NOT_SUPPORTED; @@ -3060,14 +3115,14 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( &step_remaining, sizeof(step_remaining)); - status |= attribute_store_set_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_STATUS), - &learn_status, - sizeof(learn_status)); + status + |= attribute_store_set_child_reported(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_STATUS), + &learn_status, + sizeof(learn_status)); return status; } - ///////////////////////////////////////////////////////////////////////////// // User Unique Identifier Credential Association Set/Report ///////////////////////////////////////////////////////////////////////////// @@ -3081,17 +3136,18 @@ static sl_status_t zwave_command_class_user_credential_uuic_association_set( auto credential_slot_node = attribute_store_get_first_parent_with_type( destination_credential_slot_node, ATTRIBUTE(CREDENTIAL_SLOT)); - auto credential_type_node = attribute_store_get_first_parent_with_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - auto user_id_node = attribute_store_get_first_parent_with_type( - credential_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); + auto credential_type_node + = attribute_store_get_first_parent_with_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + auto user_id_node + = attribute_store_get_first_parent_with_type(credential_type_node, + ATTRIBUTE(USER_UNIQUE_ID)); - sl_log_debug(LOG_TAG, "User Unique Identifier Credential Association Set command"); + sl_log_debug(LOG_TAG, + "User Unique Identifier Credential Association Set command"); // Set the frame - // Since the data is not linear we provide the node directly + // Since the data is not linear we provide the node directly std::vector set_data = {{ATTRIBUTE(USER_UNIQUE_ID), REPORTED_ATTRIBUTE, user_id_node}, {ATTRIBUTE(CREDENTIAL_TYPE), REPORTED_ATTRIBUTE, credential_type_node}, @@ -3105,7 +3161,6 @@ static sl_status_t zwave_command_class_user_credential_uuic_association_set( frame, frame_length); - if (status != SL_STATUS_OK) { sl_log_error( LOG_TAG, @@ -3115,27 +3170,27 @@ static sl_status_t zwave_command_class_user_credential_uuic_association_set( return status; } - sl_status_t zwave_command_class_user_credential_uuic_association_report( const zwave_controller_connection_info_t *connection_info, const uint8_t *frame_data, - uint16_t frame_length) { - + uint16_t frame_length) +{ constexpr uint8_t EXPECTED_FRAME_LENGTH = 12; if (frame_length != EXPECTED_FRAME_LENGTH) { sl_log_error(LOG_TAG, - "USER_CREDENTIAL_ASSOCIATION_REPORT frame length is not valid. Expected %d, got %d", + "USER_CREDENTIAL_ASSOCIATION_REPORT frame length is not " + "valid. Expected %d, got %d", EXPECTED_FRAME_LENGTH, frame_length); return SL_STATUS_NOT_SUPPORTED; } - constexpr uint8_t INDEX_SOURCE_USER_ID = 2; - constexpr uint8_t INDEX_SOURCE_CREDENTIAL_TYPE = 4; - constexpr uint8_t INDEX_SOURCE_CREDENTIAL_SLOT = 5; - constexpr uint8_t INDEX_DESTINATION_USER_ID = 7; - constexpr uint8_t INDEX_DESTINATION_CREDENTIAL_SLOT = 9; - constexpr uint8_t INDEX_ASSOCIATION_STATUS = 11; + constexpr uint8_t INDEX_SOURCE_USER_ID = 2; + constexpr uint8_t INDEX_SOURCE_CREDENTIAL_TYPE = 4; + constexpr uint8_t INDEX_SOURCE_CREDENTIAL_SLOT = 5; + constexpr uint8_t INDEX_DESTINATION_USER_ID = 7; + constexpr uint8_t INDEX_DESTINATION_CREDENTIAL_SLOT = 9; + constexpr uint8_t INDEX_ASSOCIATION_STATUS = 11; attribute_store_node_t endpoint_node = zwave_command_class_get_endpoint_node(connection_info); @@ -3154,7 +3209,8 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( const uint8_t association_status = frame_data[INDEX_ASSOCIATION_STATUS]; sl_log_debug(LOG_TAG, - "User Unique Identifier Credential Association Report. Source User ID: %d / " + "User Unique Identifier Credential Association Report. Source " + "User ID: %d / " "Source Credential Type: %d / Source Credential Slot: %d / " "Destination User ID: %d / Destination Credential Slot: %d", source_user_id, @@ -3176,11 +3232,12 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( REPORTED_ATTRIBUTE, source_credential_slot_node); - if (!attribute_store_node_exists(source_credential_type_node) + if (!attribute_store_node_exists(source_credential_type_node) || !attribute_store_node_exists(source_credential_slot_node)) { sl_log_error(LOG_TAG, "Can't find User %d, Credential Type %d, " - "Credential Slot %d reported by User Unique Identifier Credential Association Report", + "Credential Slot %d reported by User Unique Identifier " + "Credential Association Report", source_user_id, source_credential_type, source_credential_slot); @@ -3189,14 +3246,15 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // Set association status attribute_store_set_child_reported(source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &association_status, - sizeof(association_status)); + ATTRIBUTE(ASSOCIATION_STATUS), + &association_status, + sizeof(association_status)); // Clean up association data so ZPC won't try to send the SET command again - auto association_destination_user_id_node = attribute_store_get_first_child_by_type( - source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)); + auto association_destination_user_id_node + = attribute_store_get_first_child_by_type( + source_credential_slot_node, + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)); auto association_destination_credential_slot_node = attribute_store_get_first_child_by_type( source_credential_slot_node, @@ -3215,15 +3273,14 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // Simple case : we only have to change the slot number if (destination_user_id == source_user_id) { sl_log_info(LOG_TAG, - "Moving slot %d to slot %d (user %d)", - source_credential_slot, - destination_credential_slot, - destination_user_id); + "Moving slot %d to slot %d (user %d)", + source_credential_slot, + destination_credential_slot, + destination_user_id); - return attribute_store_set_reported( - source_credential_slot_node, - &destination_credential_slot, - sizeof(destination_credential_slot)); + return attribute_store_set_reported(source_credential_slot_node, + &destination_credential_slot, + sizeof(destination_credential_slot)); } // Complex case : we have to move the slot to another user @@ -3243,7 +3300,8 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( if (!attribute_store_node_exists(destination_user_id_node)) { sl_log_error(LOG_TAG, - "Can't find User %d reported by User Unique Identifier Credential Association Report", + "Can't find User %d reported by User Unique Identifier " + "Credential Association Report", destination_user_id); return SL_STATUS_NOT_SUPPORTED; } @@ -3282,32 +3340,32 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // Define the lambda explicitly since it is recursive https://stackoverflow.com/a/4081391 std::function deep_copy_reported_attributes; - deep_copy_reported_attributes = - [&](attribute_store::attribute cpp_current_node, - attribute_store::attribute cpp_parent_node) { - // Ignore fields that doesn't have a reported value - if (!cpp_current_node.reported_exists()) { - return; - } - attribute_store_node_t destination_node; - // If we are not at the root node, add new node - if (cpp_current_node.type() != cpp_parent_node.type()) { - destination_node - = attribute_store_add_node(cpp_current_node.type(), cpp_parent_node); - - attribute_store_copy_value(cpp_current_node, - destination_node, - REPORTED_ATTRIBUTE); - } - // Check node children - for (auto child: cpp_current_node.children()) { - // If we are not at the root, need to copy the child attribute + deep_copy_reported_attributes + = [&](attribute_store::attribute cpp_current_node, + attribute_store::attribute cpp_parent_node) { + // Ignore fields that doesn't have a reported value + if (!cpp_current_node.reported_exists()) { + return; + } + attribute_store_node_t destination_node; + // If we are not at the root node, add new node if (cpp_current_node.type() != cpp_parent_node.type()) { - cpp_parent_node = destination_node; + destination_node = attribute_store_add_node(cpp_current_node.type(), + cpp_parent_node); + + attribute_store_copy_value(cpp_current_node, + destination_node, + REPORTED_ATTRIBUTE); } - deep_copy_reported_attributes(child, cpp_parent_node); - } - }; + // Check node children + for (auto child: cpp_current_node.children()) { + // If we are not at the root, need to copy the child attribute + if (cpp_current_node.type() != cpp_parent_node.type()) { + cpp_parent_node = destination_node; + } + deep_copy_reported_attributes(child, cpp_parent_node); + } + }; deep_copy_reported_attributes(cpp_source_credential_slot_node, cpp_destination_credential_slot_node); @@ -3690,6 +3748,205 @@ sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( return SL_STATUS_OK; } + +///////////////////////////////////////////////////////////////////////////// +// User Checksum Get/Report +///////////////////////////////////////////////////////////////////////////// + +static sl_status_t zwave_command_class_user_credential_user_checksum_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "User Checksum Get"); + + auto user_id_node + = attribute_store_get_first_parent_with_type(node, + ATTRIBUTE(USER_UNIQUE_ID)); + + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error( + LOG_TAG, + "Can't find User Unique ID node. Not sending User Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } + + user_credential_user_unique_id_t user_id = 0; + sl_status_t status + = attribute_store_get_reported(user_id_node, &user_id, sizeof(user_id)); + + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't get user unique id value. Not sending User Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } + + auto exploded_value = explode_uint16(user_id); + + ZW_USER_CHECKSUM_GET_FRAME *get_frame = (ZW_USER_CHECKSUM_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = USER_CHECKSUM_GET; + get_frame->userUniqueIdentifier1 = exploded_value.msb; + get_frame->userUniqueIdentifier2 = exploded_value.lsb; + + *frame_length = sizeof(ZW_USER_CHECKSUM_GET_FRAME); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + constexpr uint8_t EXPECTED_FRAME_LENGTH = 6; + if (frame_length != EXPECTED_FRAME_LENGTH) { + sl_log_error(LOG_TAG, + "USER_CHECKSUM_REPORT frame length is not " + "valid. Expected %d, got %d", + EXPECTED_FRAME_LENGTH, + frame_length); + return SL_STATUS_NOT_SUPPORTED; + } + + constexpr uint8_t INDEX_SOURCE_USER_ID = 2; + constexpr uint8_t INDEX_USER_CHECKSUM = 4; + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // Interpret frame + const user_credential_user_unique_id_t user_id + = get_uint16_value(frame_data, INDEX_SOURCE_USER_ID); + const user_credential_checksum_t user_checksum + = get_uint16_value(frame_data, INDEX_USER_CHECKSUM); + + sl_log_debug(LOG_TAG, + "User Checksum Report. Source User ID: %d / " + "Checksum: 0x%X", + user_id, + user_checksum); + + attribute_store_node_t user_id_node; + if (!get_user_id_node(endpoint_node, + user_id, + REPORTED_ATTRIBUTE, + user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find User %d reported by User Checksum Report", + user_id); + return SL_STATUS_NOT_SUPPORTED; + } + + // Set reported value + attribute_store_set_child_reported(user_id_node, + ATTRIBUTE(USER_CHECKSUM), + &user_checksum, + sizeof(user_checksum)); + + // Compute checksum ourselves to see if it matches + std::vector checksum_data; + + // First gather all the User values + const std::vector user_attributes = { + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME), + }; + attribute_store::attribute cpp_user_id_node(user_id_node); + for (auto attribute: user_attributes) { + if (!add_node_to_checksum(checksum_data, + cpp_user_id_node.child_by_type(attribute))) { + return SL_STATUS_FAIL; + } + } + + // The all credential data + auto credential_type_node_count + = attribute_store_get_node_child_count_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE)); + + for (size_t credential_index = 0; + credential_index < credential_type_node_count; + credential_index++) { + attribute_store_node_t credential_type_node + = attribute_store_get_node_child_by_type(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_index); + auto credential_slot_node_count + = attribute_store_get_node_child_count_by_type( + credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + + for (size_t slot_index = 0; slot_index < credential_slot_node_count; + slot_index++) { + attribute_store_node_t credential_slot_node + = attribute_store_get_node_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + slot_index); + // We don't have all the data for this slot, skipping it. + if (!attribute_store_is_reported_defined(credential_slot_node)) { + sl_log_debug( + LOG_TAG, + "Credential Slot #%d is not defined. Not adding to checksum.", + slot_index); + continue; + } + + // Add credential type to checksum + if (!add_node_to_checksum(checksum_data, credential_type_node)) { + return SL_STATUS_FAIL; + } + + // Add credential slot to checksum + if (!add_node_to_checksum(checksum_data, credential_slot_node)) { + return SL_STATUS_FAIL; + } + + auto credential_data_length_node + = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + auto credential_data_node + = attribute_store_get_first_child_by_type(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA)); + + // Add credential data to checksum + if (!add_node_to_checksum(checksum_data, credential_data_node)) { + return SL_STATUS_FAIL; + } + } + } + + user_credential_checksum_t computed_checksum + = zwave_controller_crc16(CRC_INITIALIZATION_VALUE, + checksum_data.data(), + checksum_data.size()); + + if (computed_checksum != user_checksum) { + // Set checksum mismatch error + attribute_store_set_child_reported(user_id_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + &computed_checksum, + sizeof(computed_checksum)); + sl_log_error(LOG_TAG, + "Checksum mismatch for user %d. Expected 0x%X, got 0x%X", + user_id, + user_checksum, + computed_checksum); + return SL_STATUS_FAIL; + } + + // If we don't have any errors we remove the USER_CHECKSUM_MISMATCH_ERROR node + auto checksum_mismatch_node = attribute_store_get_first_child_by_type( + user_id_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR)); + attribute_store_delete_node(checksum_mismatch_node); + + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Post interview actions ///////////////////////////////////////////////////////////////////////////// @@ -4066,8 +4323,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - - // Get or create credential type node credential_type_node = add_credential_type_node_if_missing(endpoint_node, user_id, @@ -4102,7 +4357,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - if (!capabilities.is_credential_valid(credential_type, credential_slot, credential_data_vector)) { @@ -4615,7 +4869,6 @@ sl_status_t zwave_command_class_user_credential_credential_learn_stop( sizeof(stop_flag)); } - sl_status_t zwave_command_class_user_credential_uuic_association_set( attribute_store_node_t endpoint_node, user_credential_type_t credential_type, @@ -4630,9 +4883,10 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( REPORTED_ATTRIBUTE, source_user_id_node); if (!user_exists) { - sl_log_error(LOG_TAG, - "Can't find source user with ID %d. Not adding uuic association set.", - source_user_id); + sl_log_error( + LOG_TAG, + "Can't find source user with ID %d. Not adding uuic association set.", + source_user_id); return SL_STATUS_FAIL; } @@ -4645,7 +4899,8 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( if (!cred_type_exists) { sl_log_error(LOG_TAG, - "Can't find credential type %d for user %d. Not adding uuic association set.", + "Can't find credential type %d for user %d. Not adding uuic " + "association set.", credential_type, source_user_id); return SL_STATUS_FAIL; @@ -4659,7 +4914,8 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( if (!cred_slot_exists) { sl_log_error(LOG_TAG, - "Can't find source credential slot %d for credential type %d. Not adding uuic association set.", + "Can't find source credential slot %d for credential type %d. " + "Not adding uuic association set.", source_credential_slot, credential_type); return SL_STATUS_FAIL; @@ -4669,7 +4925,7 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), &destination_user_id, sizeof(destination_user_id)); - + // Slot ID last since it's this attribute that is bound to the SET command attribute_store_emplace_desired( source_credential_slot_node, @@ -4680,7 +4936,37 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_get_user_checksum( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + attribute_store_node_t user_id_node; + bool user_exists = get_user_id_node(endpoint_node, + user_id, + REPORTED_ATTRIBUTE, + user_id_node); + if (!user_exists) { + sl_log_error( + LOG_TAG, + "Can't find source user with ID %d. Not adding user checksum get.", + user_id_node); + return SL_STATUS_FAIL; + } + + auto checksum_node + = attribute_store_get_first_child_by_type(user_id_node, + ATTRIBUTE(USER_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + if (attribute_store_node_exists(checksum_node)) { + attribute_store_undefine_reported(checksum_node); + attribute_store_undefine_desired(checksum_node); + } else { + attribute_store_add_node(ATTRIBUTE(USER_CHECKSUM), user_id_node); + } + + return SL_STATUS_OK; +} ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// @@ -4741,12 +5027,16 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case USER_CHECKSUM_REPORT: + return zwave_command_class_user_credential_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); default: return SL_STATUS_NOT_SUPPORTED; } } - // Entry point sl_status_t zwave_command_class_user_credential_init() { @@ -4804,6 +5094,11 @@ sl_status_t zwave_command_class_user_credential_init() &zwave_command_class_user_credential_uuic_association_set, NULL); + attribute_resolver_register_rule( + ATTRIBUTE(USER_CHECKSUM), + NULL, + &zwave_command_class_user_credential_user_checksum_get); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 6aacf1818..8ba438862 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -319,6 +319,19 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( user_credential_user_unique_id_t destination_user_id, user_credential_slot_t destination_credential_slot); +/** + * @brief Send a User Checksum Get command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the source user. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_get_user_checksum( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index c32a9bda4..c8e5998f1 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -71,6 +71,7 @@ static std::map attributes_binding = { {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}, {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), {0, USER_CREDENTIAL_ASSOCIATION_SET}}, + {ATTRIBUTE(USER_CHECKSUM), {USER_CHECKSUM_GET, 0}}, }; // Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on @@ -350,6 +351,32 @@ void helper_simulate_credential_capabilites_report( handler.control_handler(&info, report_frame.data(), report_frame.size())); }; +void helper_simulate_credential_checksum_report( + user_credential_user_unique_id_t user_id, + user_credential_checksum_t expected_checksum, + sl_status_t expected_status = SL_STATUS_OK) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector checksum_frame + = {COMMAND_CLASS_USER_CREDENTIAL, USER_CHECKSUM_REPORT}; + auto exploded_user_id = explode_uint16(user_id); + checksum_frame.push_back(exploded_user_id.msb); + checksum_frame.push_back(exploded_user_id.lsb); + auto exploded_expected_checksum = explode_uint16(expected_checksum); + checksum_frame.push_back(exploded_expected_checksum.msb); + checksum_frame.push_back(exploded_expected_checksum.lsb); + + // Do the report + TEST_ASSERT_EQUAL(expected_status, + handler.control_handler(&info, + checksum_frame.data(), + checksum_frame.size())); +} + void helper_create_learn_status_report_frame( uint8_t credential_learn_status, user_credential_user_unique_id_t user_id, @@ -5226,5 +5253,260 @@ void test_user_credential_uuic_association_error_code() "Association status mismatch"); } +void test_get_user_checksum_with_credentials_happy_case() { + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + + user_credential_user_unique_id_t user_id = 12; + user_credential_user_type_t user_type = 0x04; + user_credential_user_active_state_t user_active_state = 0x01; + user_credential_supported_credential_rules_t credential_rules = 0x01; + user_credential_user_name_encoding_t user_name_encoding = 0x00; + std::string user_name = "Matt"; + + // Creating user + auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + // Simulate get on user + helper_test_set_get_with_args(USER_GET, + user_id_node, + {{user_id_node, DESIRED_ATTRIBUTE}}); + + auto user_report_frame = helper_create_user_report_frame(0, + 0x02, // Z-Wave + 0, + user_id, + user_type, + user_active_state, + credential_rules, + 0, + user_name_encoding, + user_name); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, user_report_frame.data(), user_report_frame.size()), + "Should have managed to create user"); + + + // Credentials + std::vector credential_types = {ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PASSWORD, + ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector credential_slots = {2, 4, 1, 8}; + + std:: + vector> + credential_data = { + {0x39, 0x32, 0x37, 0x37}, // "9277" in ASCII + {0x39, 0x35, 0x34, 0x39, 0x38, 0x38}, // "954988" in ASCII + { + 0x00, 0x7A, 0x00, 0x77, 0x00, 0x61, 0x00, 0x76, 0x00, + 0x65, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, + 0x00, 0x70, 0x00, 0x61, 0x00, 0x73, 0x00, 0x73, 0x00, + 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64}, // zwavenodepassword in Unicode UTF-16 format, in big endian order, + {0x71, 0x99} // Raw data + }; + + if (credential_types.size() != credential_slots.size() + || credential_slots.size() != credential_data.size()) { + TEST_FAIL_MESSAGE("All vectors should be the same size"); + } + + for(size_t i =0; i Date: Wed, 5 Jun 2024 09:55:41 +0200 Subject: [PATCH 19/60] UIC-3222: Credential Checksum Get/Report --- .../src/user_credential_cluster_server.cpp | 32 +- .../user_credential_cluster_server_test.cpp | 68 ++ .../attribute_store_defined_attribute_types.h | 6 +- .../zpc_attribute_store_type_registration.cpp | 2 - .../zwave_command_class_user_credential.cpp | 282 +++++++- .../src/zwave_command_class_user_credential.h | 14 + ...ave_command_class_user_credential_test.cpp | 618 +++++++++++++----- 7 files changed, 831 insertions(+), 191 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index efe4f28c6..42a230647 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -111,7 +111,9 @@ static const user_attributes_mqtt_map_t credential_rules_attributes {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), {"CredentialMaxLength"}}, {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), {"LearnRecommendedTimeout"}}, - {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), {"LearnNumberOfSteps"}}}; + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), {"LearnNumberOfSteps"}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM), {"CredentialChecksum"}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), {"CredentialChecksumError"}}}; /////////////////////////////////////////////////////////////////////////////// // DotDot MQTT incoming commands handling functions @@ -568,6 +570,31 @@ sl_status_t get_user_checksum(dotdot_unid_t unid, user_uniqueid); } +sl_status_t get_credential_checksum(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + attribute_store_node_t user_count_node + = attribute_store_get_first_child_by_type(endpoint_node, + ATTRIBUTE(NUMBER_OF_USERS)); + + return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK + : SL_STATUS_FAIL; + + } + + return zwave_command_class_user_credential_get_credential_checksum( + endpoint_node, + credential_type); +} + /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -996,5 +1023,8 @@ sl_status_t user_credential_cluster_server_init() // User Checksum uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set( &get_user_checksum); + // Credential Checksum + uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set( + &get_credential_checksum); return SL_STATUS_OK; } diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 8e810da84..5df98e0ef 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -84,6 +84,7 @@ uic_mqtt_dotdot_user_credential_credential_learn_start_modify_callback_t credent uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t credential_learn_stop_command = NULL; uic_mqtt_dotdot_user_credential_credential_association_callback_t credential_association_command = NULL; uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_user_checksum_command = NULL; +uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t get_credential_checksum_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -200,6 +201,14 @@ void uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub( get_user_checksum_command = callback; } +void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub( + const uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t + callback, + int cmock_num_calls) +{ + get_credential_checksum_command = callback; +} + /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() { @@ -281,6 +290,8 @@ void setUp() uic_mqtt_dotdot_user_credential_credential_association_callback_set_Stub(&uic_mqtt_dotdot_user_credential_credential_association_callback_set_stub); // User checksum uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub); + // Credential checksum + uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub); // clang-format on // Run the component init @@ -2294,6 +2305,63 @@ void test_user_credential_cluster_test_user_checksum_happy_case() "Checksum node reported value should be not defined"); } +void test_user_credential_cluster_test_credential_checksum_happy_case() +{ + user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; + + auto credential_type_node + = attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_credential_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + static_cast(credential_type)), + "Should be able to setup attribute store for get_credential_checksum"); + + auto checksum_node + = attribute_store_get_first_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(checksum_node), + "Checksum node should exists"); + + user_credential_checksum_t checksum = 1312; + mock_expected_cred_rule_mqtt_topic(credential_type, + "CredentialChecksum", + checksum); + attribute_store_set_reported(checksum_node, &checksum, sizeof(checksum)); + + // Try a second time to see if we still have only one checksum node + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_credential_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + static_cast(credential_type)), + "Should be able to setup attribute store for get_credential_checksum"); + + auto checksum_count + = attribute_store_get_node_child_count_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + TEST_ASSERT_EQUAL_MESSAGE(1, + checksum_count, + "Should have only one checksum attribute"); + + checksum_node + = attribute_store_get_first_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_is_reported_defined(checksum_node), + "Checksum node reported value should be not defined"); +} + /////////////////////////////////////////////////// // Support tests /////////////////////////////////////////////////// diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 2c8b9c0dc..b91faa23c 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1230,7 +1230,11 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) - +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM_MISMATCH_ERROR, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2F)) + ///////////////////////////////////////////////// // Z-Wave Plus Info CC DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_ZWAVEPLUS_INFO_VERSION, diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index 5ca597c78..303e025c3 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -514,8 +514,6 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, "User Credential Association Destination User ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, "User Credential Association Destination Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, "User Credential Association Status", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, - // Credential Checksum is under the Credential Type not Credential Slot - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, "User Credential Credential Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, // Only one learn can be active at the time, so we make this attribute on the endpoint node {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, "User Credential Credential Learn Stop Flag", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index a56ae0d8c..0978753ab 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -3749,6 +3749,55 @@ sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( return SL_STATUS_OK; } +///////////////////////////////////////////////////////////////////////////// +// Checksum helpers +///////////////////////////////////////////////////////////////////////////// + +/** + * @brief Compte the checksum and verify the checksum integrity. + * + * Compare crc16 of checksum_data and expected checksum and put it in the + * checksum_error_type if not matching. + * + * @param base_node The base node to put the error attribute + * @param checksum_error_type The type of the error attribute + * @param checksum_data The data to compute the checksum. Checksum will be 0 if empty. + * @param expected_checksum The expected checksum + * + * @return The computed checksum of checksum_data +*/ +user_credential_checksum_t compute_checksum_and_verify_integrity( + attribute_store_node_t base_node, + attribute_store_type_t checksum_error_type, + std::vector checksum_data, + user_credential_checksum_t expected_checksum) +{ + user_credential_checksum_t computed_checksum = 0; + // If checksum data is empty, the checksum is 0. The guard is present to avoid + // zwave_controller_crc16 to return CRC_INITIALIZATION_VALUE if checksum_data is empty. + // See CC:0083.01.19.11.016 & CC:0083.01.17.11.013 + if (checksum_data.size() > 0) { + computed_checksum = zwave_controller_crc16(CRC_INITIALIZATION_VALUE, + checksum_data.data(), + checksum_data.size()); + } + + if (computed_checksum != expected_checksum) { + // Set checksum mismatch error + attribute_store_set_child_reported(base_node, + checksum_error_type, + &computed_checksum, + sizeof(computed_checksum)); + } else { + // If we don't have any errors we remove the checksum_error_type node + auto checksum_mismatch_node + = attribute_store_get_first_child_by_type(base_node, checksum_error_type); + attribute_store_delete_node(checksum_mismatch_node); + } + + return computed_checksum; +} + ///////////////////////////////////////////////////////////////////////////// // User Checksum Get/Report ///////////////////////////////////////////////////////////////////////////// @@ -3920,16 +3969,13 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( } user_credential_checksum_t computed_checksum - = zwave_controller_crc16(CRC_INITIALIZATION_VALUE, - checksum_data.data(), - checksum_data.size()); + = compute_checksum_and_verify_integrity( + user_id_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + checksum_data, + user_checksum); if (computed_checksum != user_checksum) { - // Set checksum mismatch error - attribute_store_set_child_reported(user_id_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), - &computed_checksum, - sizeof(computed_checksum)); sl_log_error(LOG_TAG, "Checksum mismatch for user %d. Expected 0x%X, got 0x%X", user_id, @@ -3938,11 +3984,172 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( return SL_STATUS_FAIL; } - // If we don't have any errors we remove the USER_CHECKSUM_MISMATCH_ERROR node - auto checksum_mismatch_node = attribute_store_get_first_child_by_type( - user_id_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR)); - attribute_store_delete_node(checksum_mismatch_node); + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Credential Checksum Get/Report +///////////////////////////////////////////////////////////////////////////// + +static sl_status_t zwave_command_class_user_credential_credential_checksum_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Checksum Get"); + + auto credential_type_node = attribute_store_get_first_parent_with_type( + node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); + + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error( + LOG_TAG, + "Can't find Credential Type node. Not sending Credential Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } + + user_credential_type_t credential_type = 0; + sl_status_t status = attribute_store_get_reported(credential_type_node, + &credential_type, + sizeof(credential_type)); + + if (status != SL_STATUS_OK) { + sl_log_error( + LOG_TAG, + "Can't get credential type value. Not sending Credential Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } + + ZW_CREDENTIAL_CHECKSUM_GET_FRAME *get_frame + = (ZW_CREDENTIAL_CHECKSUM_GET_FRAME *)frame; + get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; + get_frame->cmd = CREDENTIAL_CHECKSUM_GET; + get_frame->credentialType = credential_type; + + *frame_length = sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME); + + return SL_STATUS_OK; +} + +sl_status_t + zwave_command_class_user_credential_credential_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + constexpr uint8_t EXPECTED_FRAME_LENGTH = 5; + if (frame_length != EXPECTED_FRAME_LENGTH) { + sl_log_error(LOG_TAG, + "CREDENTIAL_CHECKSUM_REPORT frame length is not " + "valid. Expected %d, got %d", + EXPECTED_FRAME_LENGTH, + frame_length); + return SL_STATUS_NOT_SUPPORTED; + } + + constexpr uint8_t INDEX_CREDENTIAL_TYPE = 2; + constexpr uint8_t INDEX_USER_CHECKSUM = 3; + + attribute_store_node_t endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + // Interpret frame + const user_credential_type_t credential_type + = frame_data[INDEX_CREDENTIAL_TYPE]; + const user_credential_checksum_t credential_checksum + = get_uint16_value(frame_data, INDEX_USER_CHECKSUM); + + sl_log_debug(LOG_TAG, + "Credential Checksum Report. Credential type: %d / " + "Checksum: 0x%X", + credential_type, + credential_checksum); + + attribute_store_node_t credential_type_node + = attribute_store_get_node_child_by_value( + endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + (uint8_t *)&credential_type, + sizeof(credential_type), + 0); + + if (!attribute_store_node_exists(credential_type_node)) { + sl_log_error( + LOG_TAG, + "Can't find Credential Type %d reported by Credential Checksum " + "Report", + credential_type); + return SL_STATUS_NOT_SUPPORTED; + } + + // Set reported value + attribute_store_set_child_reported(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM), + &credential_checksum, + sizeof(credential_checksum)); + + // Compute checksum ourselves to see if it matches + std::vector checksum_data; + + auto credential_type_nodes + = get_all_credential_type_nodes(endpoint_node, credential_type); + for (auto credential_type_node: credential_type_nodes) { + auto credential_slot_node_count + = attribute_store_get_node_child_count_by_type( + credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT)); + + for (size_t slot_index = 0; slot_index < credential_slot_node_count; + slot_index++) { + attribute_store_node_t credential_slot_node + = attribute_store_get_node_child_by_type(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + slot_index); + // We don't have all the data for this slot, skipping it. + if (!attribute_store_is_reported_defined(credential_slot_node)) { + sl_log_debug( + LOG_TAG, + "Credential Slot #%d is not defined. Not adding to checksum.", + slot_index); + continue; + } + + // Add credential slot to checksum + if (!add_node_to_checksum(checksum_data, credential_slot_node)) { + return SL_STATUS_FAIL; + } + + auto credential_data_length_node + = attribute_store_get_first_child_by_type( + credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); + auto credential_data_node + = attribute_store_get_first_child_by_type(credential_data_length_node, + ATTRIBUTE(CREDENTIAL_DATA)); + + // Add credential data to checksum + if (!add_node_to_checksum(checksum_data, credential_data_node)) { + return SL_STATUS_FAIL; + } + } + } + + user_credential_checksum_t computed_checksum + = compute_checksum_and_verify_integrity( + credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), + checksum_data, + credential_checksum); + + if (computed_checksum != credential_checksum) { + sl_log_error( + LOG_TAG, + "Checksum mismatch for credential type %d. Expected 0x%X, got 0x%X", + credential_type, + credential_checksum, + computed_checksum); + return SL_STATUS_FAIL; + } return SL_STATUS_OK; } @@ -4948,7 +5155,7 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( if (!user_exists) { sl_log_error( LOG_TAG, - "Can't find source user with ID %d. Not adding user checksum get.", + "Can't find source user with ID %d. Not setting up User Checksum Get.", user_id_node); return SL_STATUS_FAIL; } @@ -4967,6 +5174,43 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( return SL_STATUS_OK; } + +sl_status_t zwave_command_class_user_credential_get_credential_checksum( + attribute_store_node_t endpoint_node, user_credential_type_t credential_type) +{ + attribute_store_node_t supported_credential_type_node + = attribute_store_get_node_child_by_value( + endpoint_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + &credential_type, + sizeof(credential_type), + 0); + + if (!attribute_store_node_exists(supported_credential_type_node)) { + sl_log_error( + LOG_TAG, + "Can't find supported credential type %d. Not setting up Checksum get.", + credential_type); + return SL_STATUS_FAIL; + } + + auto checksum_node + = attribute_store_get_first_child_by_type(supported_credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + // If node already exists, we clear its value to trigger the GET + if (attribute_store_node_exists(checksum_node)) { + attribute_store_undefine_reported(checksum_node); + attribute_store_undefine_desired(checksum_node); + } else { + attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), + supported_credential_type_node); + } + + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Class logic ///////////////////////////////////////////////////////////////////////////// @@ -5032,6 +5276,11 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case CREDENTIAL_CHECKSUM_REPORT: + return zwave_command_class_user_credential_credential_checksum_handle_report( + connection_info, + frame_data, + frame_length); default: return SL_STATUS_NOT_SUPPORTED; } @@ -5099,6 +5348,11 @@ sl_status_t zwave_command_class_user_credential_init() NULL, &zwave_command_class_user_credential_user_checksum_get); + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_checksum_get); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 8ba438862..71e6b2ef3 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -332,6 +332,20 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id); + +/** + * @brief Send a Credential Checksum Get command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. Cannot be 0 + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the credential_type is not supported or is 0. + */ +sl_status_t zwave_command_class_user_credential_get_credential_checksum( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type); + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index c8e5998f1..46b65e7a8 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -72,6 +72,7 @@ static std::map attributes_binding = { {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), {0, USER_CREDENTIAL_ASSOCIATION_SET}}, {ATTRIBUTE(USER_CHECKSUM), {USER_CHECKSUM_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM), {CREDENTIAL_CHECKSUM_GET, 0}}, }; // Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on @@ -351,10 +352,10 @@ void helper_simulate_credential_capabilites_report( handler.control_handler(&info, report_frame.data(), report_frame.size())); }; -void helper_simulate_credential_checksum_report( +void helper_simulate_user_checksum_report( user_credential_user_unique_id_t user_id, user_credential_checksum_t expected_checksum, - sl_status_t expected_status = SL_STATUS_OK) + sl_status_t expected_status = SL_STATUS_OK) { zwave_controller_connection_info_t info = {}; info.remote.node_id = node_id; @@ -377,6 +378,30 @@ void helper_simulate_credential_checksum_report( checksum_frame.size())); } +void helper_simulate_credential_checksum_report( + user_credential_type_t credential_type, + user_credential_checksum_t expected_checksum, + sl_status_t expected_status = SL_STATUS_OK) +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + std::vector checksum_frame + = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_CHECKSUM_REPORT}; + checksum_frame.push_back(credential_type); + auto exploded_expected_checksum = explode_uint16(expected_checksum); + checksum_frame.push_back(exploded_expected_checksum.msb); + checksum_frame.push_back(exploded_expected_checksum.lsb); + + // Do the report + TEST_ASSERT_EQUAL(expected_status, + handler.control_handler(&info, + checksum_frame.data(), + checksum_frame.size())); +} + void helper_create_learn_status_report_frame( uint8_t credential_learn_status, user_credential_user_unique_id_t user_id, @@ -858,6 +883,143 @@ void helper_test_credential_data(attribute_store_node_t credential_slot_node, "Modifier type mismatch"); } +std::vector helper_create_credential_report_frame( + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + uint8_t crb, + std::vector credential_data, + user_credential_modifier_type_t credential_modifier_type, + user_credential_modifier_node_id_t credential_modifier_node_id, + user_credential_type_t next_credential_type, + user_credential_slot_t next_credential_slot) +{ + std::vector report_frame + = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_REPORT}; + + auto exploded_user_id = explode_uint16(user_id); + report_frame.push_back(exploded_user_id.msb); + report_frame.push_back(exploded_user_id.lsb); + + report_frame.push_back(credential_type); + + auto exploded_credential_slot = explode_uint16(credential_slot); + report_frame.push_back(exploded_credential_slot.msb); + report_frame.push_back(exploded_credential_slot.lsb); + + report_frame.push_back(crb << 7); + report_frame.push_back(credential_data.size()); + + for (uint8_t credential_value: credential_data) { + report_frame.push_back(credential_value); + } + + report_frame.push_back(credential_modifier_type); + auto exploded_credential_modifier_node_id + = explode_uint16(credential_modifier_node_id); + report_frame.push_back(exploded_credential_modifier_node_id.msb); + report_frame.push_back(exploded_credential_modifier_node_id.lsb); + + report_frame.push_back(next_credential_type); + auto exploded_next_credential_slot = explode_uint16(next_credential_slot); + report_frame.push_back(exploded_next_credential_slot.msb); + report_frame.push_back(exploded_next_credential_slot.lsb); + + return report_frame; +}; + +void helper_create_credential_checksum_structure() +{ + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + + // Since credential are attached to an user we simulate somes users + std::vector user_ids = {12, 15, 18}; + std::map + user_id_nodes = {}; + + for (auto user_id: user_ids) { + user_id_nodes.insert({user_id, + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id))}); + } + + // Create simulated envrionment for credentials + helper_simulate_credential_capabilites_report(1, + {ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PASSWORD, + ZCL_CRED_TYPE_EYE_BIOMETRIC}, + {1, 1, 1}, + {8, 8, 8}, + {2, 34, 5}, + {6, 6, 10}, + {20, 20, 2}, + {1, 1, 95}); + + std::vector credential_user_ids + = {user_ids[0], user_ids[1], user_ids[0], user_ids[2]}; + + std::vector credential_types + = {ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PASSWORD, + ZCL_CRED_TYPE_EYE_BIOMETRIC}; + std::vector credential_slots = {2, 4, 1, 8}; + + std:: + vector> + credential_data = { + {0x39, 0x32, 0x37, 0x37}, // "9277" in ASCII + {0x39, 0x35, 0x34, 0x39, 0x38, 0x38}, // "954988" in ASCII + { + 0x00, 0x7A, 0x00, 0x77, 0x00, 0x61, 0x00, 0x76, 0x00, + 0x65, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, + 0x00, 0x70, 0x00, 0x61, 0x00, 0x73, 0x00, 0x73, 0x00, + 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64}, // zwavenodepassword in Unicode UTF-16 format, in big endian order, + {0x24, 0x01} // Raw data + }; + + if (credential_types.size() != credential_slots.size() + || credential_slots.size() != credential_data.size() + || credential_slots.size() != credential_user_ids.size()) { + TEST_FAIL_MESSAGE("All vectors should be the same size"); + } + + for (size_t i = 0; i < credential_types.size(); i++) { + // Simulate credential type and slot to get the credential report to work + auto user_credential_type_node + = attribute_store_emplace(user_id_nodes[credential_user_ids[i]], + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_types[i], + sizeof(credential_types[i])); + attribute_store_emplace(user_credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + &credential_slots[i], + sizeof(credential_slots[i])); + auto credential_frame + = helper_create_credential_report_frame(credential_user_ids[i], + credential_types[i], + credential_slots[i], + 0, + credential_data[i], + 0x02, // Anything but 0 + 0, + 0, + 0); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, + credential_frame.data(), + credential_frame.size()), + "Credential report should have returned SL_STATUS_OK"); + } +} + ///////////////////////////////////////////////////// // Test case ///////////////////////////////////////////////////// @@ -1952,51 +2114,6 @@ void test_user_credential_credential_get_no_credential_type() helper_test_set_get_with_args(CREDENTIAL_GET, ATTRIBUTE_STORE_INVALID_NODE); } -std::vector helper_create_credential_report_frame( - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - uint8_t crb, - std::vector credential_data, - user_credential_modifier_type_t credential_modifier_type, - user_credential_modifier_node_id_t credential_modifier_node_id, - user_credential_type_t next_credential_type, - user_credential_slot_t next_credential_slot) -{ - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_REPORT}; - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(credential_type); - - auto exploded_credential_slot = explode_uint16(credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); - - report_frame.push_back(crb << 7); - report_frame.push_back(credential_data.size()); - - for (uint8_t credential_value: credential_data) { - report_frame.push_back(credential_value); - } - - report_frame.push_back(credential_modifier_type); - auto exploded_credential_modifier_node_id - = explode_uint16(credential_modifier_node_id); - report_frame.push_back(exploded_credential_modifier_node_id.msb); - report_frame.push_back(exploded_credential_modifier_node_id.lsb); - - report_frame.push_back(next_credential_type); - auto exploded_next_credential_slot = explode_uint16(next_credential_slot); - report_frame.push_back(exploded_next_credential_slot.msb); - report_frame.push_back(exploded_next_credential_slot.lsb); - - return report_frame; -}; - void test_user_credential_credential_report_no_credential() { zwave_controller_connection_info_t info = {}; @@ -4932,9 +5049,9 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex sizeof(destination_user_id)); // Already present type attribute_store_emplace(destination_user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); + ATTRIBUTE(CREDENTIAL_TYPE), + &credential_type, + sizeof(credential_type)); helper_fill_credential_data(source_nodes.credential_slot_node, credential_data, @@ -5165,7 +5282,8 @@ void test_user_credential_uuic_association_error_code() // Credential data std::string credential_data = "123456"; user_credential_modifier_type_t modifier_type = 5; - uint8_t association_status = USER_CREDENTIAL_ASSOCIATION_REPORT_SOURCE_CREDENTIAL_SLOT_EMPTY; + uint8_t association_status + = USER_CREDENTIAL_ASSOCIATION_REPORT_SOURCE_CREDENTIAL_SLOT_EMPTY; auto source_nodes = helper_create_credential_structure(source_user_id, credential_type, @@ -5225,47 +5343,47 @@ void test_user_credential_uuic_association_error_code() "Source Credential type node should have one children"); // No move should have been performed - TEST_ASSERT_EQUAL_MESSAGE( + TEST_ASSERT_EQUAL_MESSAGE( 0, attribute_store_get_node_child_count(destination_user_id_node), "Nothing should have changed for destination user ID node"); // Test source credential slot node - auto destination_credential_slot_node = source_nodes.credential_slot_node; - user_credential_slot_t reported_credential_slot; - attribute_store_get_reported(destination_credential_slot_node, - &reported_credential_slot, - sizeof(reported_credential_slot)); - TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, - reported_credential_slot, - "Credential slot mismatch"); - - helper_test_credential_data(destination_credential_slot_node, - credential_data, - modifier_type); - uint8_t reported_status; - attribute_store_get_child_reported(destination_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &reported_status, - sizeof(reported_status)); - TEST_ASSERT_EQUAL_MESSAGE(association_status, - reported_status, - "Association status mismatch"); + auto destination_credential_slot_node = source_nodes.credential_slot_node; + user_credential_slot_t reported_credential_slot; + attribute_store_get_reported(destination_credential_slot_node, + &reported_credential_slot, + sizeof(reported_credential_slot)); + TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, + reported_credential_slot, + "Credential slot mismatch"); + + helper_test_credential_data(destination_credential_slot_node, + credential_data, + modifier_type); + uint8_t reported_status; + attribute_store_get_child_reported(destination_credential_slot_node, + ATTRIBUTE(ASSOCIATION_STATUS), + &reported_status, + sizeof(reported_status)); + TEST_ASSERT_EQUAL_MESSAGE(association_status, + reported_status, + "Association status mismatch"); } -void test_get_user_checksum_with_credentials_happy_case() { +void test_get_user_checksum_with_credentials_happy_case() +{ zwave_controller_connection_info_t info = {}; info.remote.node_id = node_id; info.remote.endpoint_id = endpoint_id; info.local.is_multicast = false; - - user_credential_user_unique_id_t user_id = 12; - user_credential_user_type_t user_type = 0x04; - user_credential_user_active_state_t user_active_state = 0x01; + user_credential_user_unique_id_t user_id = 12; + user_credential_user_type_t user_type = 0x04; + user_credential_user_active_state_t user_active_state = 0x01; user_credential_supported_credential_rules_t credential_rules = 0x01; - user_credential_user_name_encoding_t user_name_encoding = 0x00; - std::string user_name = "Matt"; + user_credential_user_name_encoding_t user_name_encoding = 0x00; + std::string user_name = "Matt"; // Creating user auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, @@ -5278,26 +5396,27 @@ void test_get_user_checksum_with_credentials_happy_case() { {{user_id_node, DESIRED_ATTRIBUTE}}); auto user_report_frame = helper_create_user_report_frame(0, - 0x02, // Z-Wave - 0, - user_id, - user_type, - user_active_state, - credential_rules, - 0, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, user_report_frame.data(), user_report_frame.size()), - "Should have managed to create user"); - + 0x02, // Z-Wave + 0, + user_id, + user_type, + user_active_state, + credential_rules, + 0, + user_name_encoding, + user_name); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to create user"); // Credentials - std::vector credential_types = {ZCL_CRED_TYPE_PIN_CODE, - ZCL_CRED_TYPE_PIN_CODE, - ZCL_CRED_TYPE_PASSWORD, - ZCL_CRED_TYPE_HAND_BIOMETRIC}; + std::vector credential_types + = {ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PASSWORD, + ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector credential_slots = {2, 4, 1, 8}; std:: @@ -5312,40 +5431,42 @@ void test_get_user_checksum_with_credentials_happy_case() { 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64}, // zwavenodepassword in Unicode UTF-16 format, in big endian order, {0x71, 0x99} // Raw data }; - + if (credential_types.size() != credential_slots.size() || credential_slots.size() != credential_data.size()) { TEST_FAIL_MESSAGE("All vectors should be the same size"); } - for(size_t i =0; i tested_credential_types + = {ZCL_CRED_TYPE_PIN_CODE, + ZCL_CRED_TYPE_PASSWORD, + ZCL_CRED_TYPE_EYE_BIOMETRIC, + ZCL_CRED_TYPE_RFID_CODE}; + + std::vector expected_checksums + = {0xD867, 0x6F76, 0xC06E, 0x0000}; + + // Create empty RFID_CODE + user_credential_type_t rfid_type = ZCL_CRED_TYPE_RFID_CODE; + attribute_store_emplace(endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + &rfid_type, + sizeof(rfid_type)); + + if (tested_credential_types.size() != expected_checksums.size()) { + TEST_FAIL_MESSAGE("All vectors should be the same size"); + } + + for (size_t i = 0; i < tested_credential_types.size(); i++) { + auto current_credential_type = tested_credential_types[i]; + auto current_credential_type_node = attribute_store_get_node_child_by_value( + endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + ¤t_credential_type, + sizeof(current_credential_type), + 0); + + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(current_credential_type_node), + "Credential type node should exist"); + + // Get checksum + auto checksum_node + = attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), + current_credential_type_node); + + helper_test_set_get_with_args( + CREDENTIAL_CHECKSUM_GET, + checksum_node, + {{current_credential_type_node, REPORTED_ATTRIBUTE}}); + + user_credential_checksum_t expected_checksum = expected_checksums[i]; + helper_simulate_credential_checksum_report(current_credential_type, + expected_checksum); + + // Check if checksum is correct + user_credential_checksum_t reported_checksum; + attribute_store_get_reported(checksum_node, + &reported_checksum, + sizeof(reported_checksum)); + TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, + reported_checksum, + (std::string("Checksum mismatch for type ") + + std::to_string(current_credential_type)) + .c_str()); + } +} + +void test_get_credential_checksum_mismatch() +{ + helper_create_credential_checksum_structure(); + + std::vector tested_credential_types + = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_PASSWORD}; + + std::vector expected_checksums = {0xD867, 0x6F76}; + + if (tested_credential_types.size() != expected_checksums.size()) { + TEST_FAIL_MESSAGE("All vectors should be the same size"); + } + + for (size_t i = 0; i < tested_credential_types.size(); i++) { + auto current_credential_type = tested_credential_types[i]; + auto current_credential_type_node = attribute_store_get_node_child_by_value( + endpoint_id_node, + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + REPORTED_ATTRIBUTE, + ¤t_credential_type, + sizeof(current_credential_type), + 0); + + TEST_ASSERT_TRUE_MESSAGE( + attribute_store_node_exists(current_credential_type_node), + "Credential type node should exist"); + + // Get checksum + auto checksum_node + = attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), + current_credential_type_node); + + helper_test_set_get_with_args( + CREDENTIAL_CHECKSUM_GET, + checksum_node, + {{current_credential_type_node, REPORTED_ATTRIBUTE}}); + + user_credential_checksum_t error_checksum = expected_checksums[i] + 1; + helper_simulate_credential_checksum_report(current_credential_type, + error_checksum, + SL_STATUS_FAIL); + + // Check error checksum + user_credential_checksum_t reported_mismatch_checksum; + user_credential_checksum_t reported_error_checksum; + + attribute_store_get_reported(checksum_node, + &reported_error_checksum, + sizeof(reported_error_checksum)); + + TEST_ASSERT_EQUAL_MESSAGE(error_checksum, + reported_error_checksum, + "Reported checksum mismatch"); + + auto mismatch_checksum_node = attribute_store_get_first_child_by_type( + current_credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR)); + + attribute_store_get_reported(mismatch_checksum_node, + &reported_mismatch_checksum, + sizeof(reported_mismatch_checksum)); + + TEST_ASSERT_EQUAL_MESSAGE(expected_checksums[i], + reported_mismatch_checksum, + "Mismatch checksum mismatch"); + + // Try again with correct checksum + + user_credential_checksum_t expected_checksum = expected_checksums[i]; + helper_simulate_credential_checksum_report(current_credential_type, + expected_checksum); + + // Check if checksum is correct + user_credential_checksum_t reported_checksum; + attribute_store_get_reported(checksum_node, + &reported_checksum, + sizeof(reported_checksum)); + + TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, + reported_checksum, + "Checksum mismatch"); + + TEST_ASSERT_FALSE_MESSAGE( + attribute_store_node_exists(mismatch_checksum_node), + "Mismatch checksum node should have been removed"); + } +} + } // extern "C" \ No newline at end of file From e580bc1bd79dd0c0d66a38a58e4159bcf6857b3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 10 Jun 2024 14:40:06 +0200 Subject: [PATCH 20/60] UIC-3222: Expose CredentialLearnStatus to MQTT --- .../src/user_credential_cluster_server.cpp | 3 ++- .../test/user_credential_cluster_server_test.cpp | 13 +++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 42a230647..ec01364fb 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -102,7 +102,8 @@ static const user_attributes_mqtt_map_t credential_attributes {"CredentialModifierType", user_modifier_type_get_enum_value_name}}, {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), {"CredentialModifierNodeId"}}, {ATTRIBUTE(CREDENTIAL_DATA), {"CredentialData"}}, - {ATTRIBUTE(ASSOCIATION_STATUS), {"AssociationStatus"}}}; + {ATTRIBUTE(ASSOCIATION_STATUS), {"AssociationStatus"}}, + {ATTRIBUTE(CREDENTIAL_LEARN_STATUS), {"CredentialLearnStatus"}}}; static const user_attributes_mqtt_map_t credential_rules_attributes = {{ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), {"LearnSupport", convert_to_bool}}, diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 5df98e0ef..fa12d1772 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -438,6 +438,7 @@ void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, // WARNING : Order here matters based on their initialization order in the add_complete_credential function std::vector attribute_names = {"CredentialData", "AssociationStatus", + "CredentialLearnStatus", "CredentialModifierNodeId", "CredentialModifierType"}; for (auto &attribute_name: attribute_names) { @@ -812,6 +813,18 @@ attribute_store_node_t &association_status, sizeof(association_status)); + // Test credential learn status exposure (will not be used anywhere, it is here to test the MQTT exposure) + uint8_t credential_learn_status = 1; + mock_expected_cred_mqtt_topic( + user_id, + credential_type, + credential_slot, + "CredentialLearnStatus", + credential_learn_status); + attribute_store_emplace(credential_slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_STATUS), + &credential_learn_status, + sizeof(credential_learn_status)); // Generated by end device user_credential_modifier_node_id_t modifier_node_id = 1212; From 3cd8017d73e8f460a4c0f1490ae2d56b4c2c2d85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 15 Jul 2024 17:05:58 +0200 Subject: [PATCH 21/60] UIC-3222: Align to ZW_classcmd.h latest constants --- .../src/zwave_command_class_user_credential.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 0978753ab..5ad033443 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -3084,7 +3084,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( attribute_store_delete_node(credential_slot_node); } break; - case CREDENTIAL_LEARN_REPORT_INVALID_ADD_OPERATION_TYPE: + case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_ADD_OPERATION_TYPE: sl_log_error( LOG_TAG, "Invalid Add Operation Type for User %d, Credential Type %d, " @@ -3093,7 +3093,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( credential_type, credential_slot); break; - case CREDENTIAL_LEARN_REPORT_INVALID_MODIFY_OPERATION_TYPE: + case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_MODIFY_OPERATION_TYPE: sl_log_error( LOG_TAG, "Invalid Modify Operation Type for User %d, Credential Type %d, " From 2c1b01ef04d789a7dd1f8fdc88983e9636f33dd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 30 Jul 2024 17:11:53 +0200 Subject: [PATCH 22/60] UIC-3222: Credential data is now a uint8_t instead of uint16_t Refactoring report function to use new C++ helpers --- .../user_credential_cluster_server_test.cpp | 6 +- .../zpc_attribute_store_type_registration.cpp | 4 +- .../zwave_command_class_user_credential.cpp | 225 +++++++++--------- ...ave_command_class_user_credential_test.cpp | 107 +++++---- 4 files changed, 168 insertions(+), 174 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index fa12d1772..cf625ea13 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -1,6 +1,6 @@ /****************************************************************************** * # License - * Copyright 2023 Silicon Laboratories Inc. www.silabs.com + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com ****************************************************************************** * The licensor of this software is Silicon Laboratories Inc. Your use of this * software is governed by the terms of Silicon Labs Master Software License @@ -537,8 +537,8 @@ void setup_cred_capabilities() sizeof(cred_type)); uint8_t crb_support = 1; uint16_t slot_supported = 0xFFFF; - uint16_t cred_min_length = 0; - uint16_t cred_max_length = 0xFF; + uint8_t cred_min_length = 0; + uint8_t cred_max_length = 0xFF; uint8_t learn_timeout = 112; uint8_t learn_steps = 12; diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index 303e025c3..0be000dfc 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -475,8 +475,8 @@ static const std::vector attribute_schema = { {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, "User Credential Supported Credential Type", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_SUPPORT, "User Credential Learn Support", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, "User Credential Supported Slot Count", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, "User Credential Min Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, "User Credential Max Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, "User Credential Min Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, "User Credential Max Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, "User Credential Learn Recommended Timeout", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, "User Credential Learn Number Of Steps", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, "User Credential Credential Checksum", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 5ad033443..7ee38c320 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -46,6 +46,8 @@ // Cpp Attribute store #include "attribute.hpp" +#include "zwave_frame_generator.hpp" +#include "zwave_frame_parser.hpp" // UTF16 conversion (deprecated in C++17) // Needed for credential data (password) per specification @@ -53,14 +55,16 @@ #include // Macro -#define LOG_TAG "zwave_command_class_user_credential" #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +// Constexpr +constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; // Used to get user names // If the user name has a size > to this number, we will truncate it // Specification says that payload data should not exceeded 64 bytes. -#define MAX_CHAR_SIZE 64 +constexpr uint8_t MAX_CHAR_SIZE = 64; // Used to compute checksums -#define CRC_INITIALIZATION_VALUE 0x1D0F +constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; /** * @brief Implementation notes * @@ -72,6 +76,11 @@ * */ +namespace +{ +zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); +} + ///////////////////////////////////////////////////////////////////////////// // Preemptive declarations ///////////////////////////////////////////////////////////////////////////// @@ -233,8 +242,8 @@ struct credential_capabilities { user_credential_type_t credential_type = 0; uint16_t max_slot_count = 0; uint8_t learn_support = 0; - uint16_t min_credential_length = 0; - uint16_t max_credential_length = 0; + uint8_t min_credential_length = 0; + uint8_t max_credential_length = 0; uint8_t learn_recommended_timeout = 0; uint8_t learn_number_of_steps = 0; @@ -2026,141 +2035,123 @@ static sl_status_t { sl_log_debug(LOG_TAG, "Credential Capabilities Get"); - ZW_CREDENTIAL_CAPABILITIES_GET_FRAME *get_frame - = (ZW_CREDENTIAL_CAPABILITIES_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = CREDENTIAL_CAPABILITIES_GET; - *frame_length = sizeof(ZW_CREDENTIAL_CAPABILITIES_GET_FRAME); - return SL_STATUS_OK; + return frame_generator.generate_no_args_frame(CREDENTIAL_CAPABILITIES_GET, + frame, + frame_length); + ; } + sl_status_t zwave_command_class_user_credential_credential_capabilities_handle_report( const zwave_controller_connection_info_t *connection_info, const uint8_t *frame_data, uint16_t frame_length) { - if (frame_length < 5) { - return SL_STATUS_NOT_SUPPORTED; - } - sl_log_debug(LOG_TAG, "Credential Capabilities Report"); + + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + const uint8_t min_expected_size = 5; - uint8_t support_credential_checksum - = (frame_data[2] - & CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK) - > 0; - - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), - &support_credential_checksum, - sizeof(support_credential_checksum)); + try { + zwave_frame_parser parser(frame_data, frame_length); - uint8_t supported_credential_types_count = frame_data[3]; - - // Remove all previous known CREDENTIAL_TYPE - attribute_store_node_t type_node; - do { - type_node = attribute_store_get_node_child_by_type( - endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - 0); - attribute_store_delete_node(type_node); - } while (type_node != ATTRIBUTE_STORE_INVALID_NODE); - - uint16_t ucl_credential_type_mask = 0; + // We only needs to check the minimum size here + if (!parser.is_frame_size_valid(min_expected_size, + UINT8_MAX)) { + sl_log_error(LOG_TAG, + "Invalid frame size for Credential Capabilities Report frame"); + return SL_STATUS_FAIL; + } - uint16_t current_index = 4; - for (uint8_t i = 0; i < supported_credential_types_count; i++) { - // > Root node : Credential Type - user_credential_type_t credential_type = frame_data[current_index]; + // TODO: Add admin code support + parser.read_byte_with_bitmask( + {{CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM))}}); + + uint8_t supported_credential_types_count = parser.read_byte(); + + // Remove all previous known SUPPORTED_CREDENTIAL_TYPE + attribute_store::attribute type_node; + do { + // Take first supported credential type node + endpoint_node.child_by_type(ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)) + .delete_node(); + } while (endpoint_node.child_by_type(ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)) + .is_valid()); + + // Compute this value here since we need it for the exposure of the supported user credential types + uint16_t ucl_credential_type_mask = 0; + + // Create each node with credential type + std::vector credential_type_nodes; + for (uint8_t current_credential_type_index = 0; + current_credential_type_index < supported_credential_types_count; + current_credential_type_index++) { + // Create new node + auto current_credential_type_node + = endpoint_node.add_node(ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); + // Read credential type and save into the node + auto credential_type = parser.read_byte(current_credential_type_node); + // Compute bitmask for MQTT + ucl_credential_type_mask |= (1 << (credential_type - 1)); + // Save the credential type node for later + credential_type_nodes.push_back(current_credential_type_node); + } - ucl_credential_type_mask |= (1 << (credential_type - 1)); + // CL Support + for (uint8_t current_credential_type_index = 0; + current_credential_type_index < supported_credential_types_count; + current_credential_type_index++) { + // Create new node + auto credential_learn_support_node + = credential_type_nodes[current_credential_type_index].add_node( + ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT)); + parser.read_byte_with_bitmask( + {CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK, + credential_learn_support_node}); + } - attribute_store_node_t credential_type_node - = attribute_store_emplace(endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); + // Number of Supported Credential Slots + for (uint8_t current_credential_type_index = 0; + current_credential_type_index < supported_credential_types_count; + current_credential_type_index++) { + auto credential_learn_support_node + = credential_type_nodes[current_credential_type_index].add_node( + ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT)); - if (credential_type_node == ATTRIBUTE_STORE_INVALID_NODE) { - sl_log_error(LOG_TAG, "Unable to create credential type node"); - return SL_STATUS_NOT_SUPPORTED; + parser.read_sequential(2, credential_learn_support_node); } - sl_log_debug(LOG_TAG, "Supported credential type : %d", credential_type); - - // >> CL Support - // Use same define as Credential Checksum Support here since it's a same and no define is available for cl support - uint8_t cl_support_index = current_index + supported_credential_types_count; - uint8_t support_cl - = (frame_data[cl_support_index] - & CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK) - > 0; - - attribute_store_set_child_reported(credential_type_node, - ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), - &support_cl, - sizeof(support_cl)); - - // >> 16 bits values - auto store_uint16_value = [&](attribute_store_type_t type, uint8_t offset) { - // First 16bit value after CL Support is cl_support_index + supported_credential_types_count - // Then we add the 16 bit value offset to it : - // - CREDENTIAL_SUPPORTED_SLOT_COUNT [0] : supported_credential_types_count x 2 x [0] (base) - // - CREDENTIAL_MIN_LENGTH [1] : supported_credential_types_count x 2 x [1] (one batch of 16 bit data before) - // - CREDENTIAL_MAX_LENGTH [2] : supported_credential_types_count x 2 x [2] (two batch of 16 bit data before) - // Then we add i to it (0..n) to make sure we take the right pair of data to form the 16 bit unsigned integer - const uint16_t index = cl_support_index + supported_credential_types_count - + (supported_credential_types_count * 2 * offset) - + i; - uint16_t value = get_uint16_value(frame_data, index); - attribute_store_set_child_reported(credential_type_node, - type, - &value, - sizeof(value)); + auto create_and_store_uint8_value = [&](attribute_store_type_t type) { + for (uint8_t current_credential_type_index = 0; + current_credential_type_index < supported_credential_types_count; + current_credential_type_index++) { + auto node = credential_type_nodes[current_credential_type_index].add_node(type); + parser.read_byte(node); + } }; - store_uint16_value(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), 0); - store_uint16_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH), 1); - store_uint16_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH), 2); + create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH)); + create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH)); + create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)); + create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS)); - // End for Credential Max Length values - const uint8_t offset = 3; - const uint16_t cl_recommended_index - = cl_support_index + supported_credential_types_count - + (supported_credential_types_count * 2 * offset); - uint8_t recommended_timeout = frame_data[cl_recommended_index]; - attribute_store_set_child_reported( - credential_type_node, - ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), - &recommended_timeout, - sizeof(recommended_timeout)); - - // Offset of supported_credential_types_count for next 8 bit value - const uint16_t cl_number_of_steps_index - = cl_recommended_index + supported_credential_types_count; - uint8_t cl_number_of_steps = frame_data[cl_number_of_steps_index]; - attribute_store_set_child_reported( - credential_type_node, - ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), - &cl_number_of_steps, - sizeof(cl_number_of_steps)); - current_index++; + // Set UCL mask for supported user credential types + endpoint_node + .emplace_node( + DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES) + .set_reported(ucl_credential_type_mask); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Capabilities Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } - - // Set UCL mask for supported user credential types - attribute_store_set_child_reported( - endpoint_node, - DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, - &ucl_credential_type_mask, - sizeof(ucl_credential_type_mask)); - - return SL_STATUS_OK; + return SL_STATUS_OK; } ///////////////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 46b65e7a8..20384cf5b 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -291,8 +291,8 @@ void helper_simulate_credential_capabilites_report( std::vector credential_type, std::vector cl_support, std::vector supported_credential_slots, - std::vector min_length, - std::vector max_length, + std::vector min_length, + std::vector max_length, std::vector cl_timeout, std::vector cl_steps) { @@ -335,8 +335,13 @@ void helper_simulate_credential_capabilites_report( } push_uint16(supported_credential_slots); - push_uint16(min_length); - push_uint16(max_length); + + for (auto &c: min_length) { + report_frame.push_back(c); + } + for (auto &c: max_length) { + report_frame.push_back(c); + } for (auto &c: cl_timeout) { report_frame.push_back(c); @@ -1252,11 +1257,11 @@ void test_user_credential_credential_capabilities_report_happy_case() std::vector credential_type = {1, 3, 4, 5}; std::vector cl_support = {1, 0, 0, 1}; std::vector supported_credential_slots = {1233, 11233, 21233, 33}; - std::vector min_length = {2, 2362, 255, 1255}; - std::vector max_length = {5632, 15632, 25632, 32568}; - std::vector cl_timeout = {100, 0, 0, 128}; - std::vector cl_steps = {2, 0, 0, 12}; - uint16_t expected_credential_type_mask = 0b11101; + std::vector min_length = {2, 23, 255, 12}; + std::vector max_length = {56, 156, 255, 32}; + std::vector cl_timeout = {100, 0, 0, 128}; + std::vector cl_steps = {2, 0, 0, 12}; + uint16_t expected_credential_type_mask = 0b11101; auto test_report_values = [&]() { std::map uint8_attribute_map @@ -1289,16 +1294,14 @@ void test_user_credential_credential_capabilities_report_happy_case() "Incorrect credential type"); uint8_attribute_map = { + {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), min_length[i]}, + {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), max_length[i]}, {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), cl_support[i]}, {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), cl_timeout[i]}, {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), cl_steps[i]}, }; - uint16_attribute_map = { - {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), - supported_credential_slots[i]}, - {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), min_length[i]}, - {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), max_length[i]}, - }; + uint16_attribute_map = {{ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), + supported_credential_slots[i]}}; helper_test_attribute_store_values(uint8_attribute_map, type_node); helper_test_attribute_store_values(uint16_attribute_map, type_node); } @@ -1322,7 +1325,7 @@ void test_user_credential_credential_capabilities_report_happy_case() cl_support = {0, 1, 1}; supported_credential_slots = {15, 1565, 153}; min_length = {155, 15, 5}; - max_length = {1111, 111, 11}; + max_length = {180, 111, 11}; cl_timeout = {0, 10, 12}; cl_steps = {0, 1, 2}; expected_credential_type_mask = 0b11100000; @@ -2734,8 +2737,8 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; - std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {6}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -2829,8 +2832,8 @@ void test_user_credential_add_credential_invalid_slot() = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; - std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {6}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -3059,8 +3062,8 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; - std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {6}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -3485,8 +3488,8 @@ void test_user_credential_credential_add_capabilites_failure_cases() = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; - std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {6}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -3565,8 +3568,8 @@ void test_user_credential_credential_add_capabilites_happy_case() = {ZCL_CRED_TYPE_HAND_BIOMETRIC, ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1, 0}; std::vector supported_credential_slots = {1, 5}; - std::vector supported_cred_min_length = {2, 4}; - std::vector supported_cred_max_length = {6, 8}; + std::vector supported_cred_min_length = {2, 4}; + std::vector supported_cred_max_length = {6, 8}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -3623,8 +3626,8 @@ void test_user_credential_credential_modify_capabilites_failure_cases() = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; - std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {7}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {7}; helper_simulate_credential_capabilites_report(supported_credential_checksum, supported_credential_type, supported_cl, @@ -4430,8 +4433,8 @@ void test_user_credential_credential_learn_start_add_happy_case() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4523,8 +4526,8 @@ void test_user_credential_credential_learn_start_add_cl_not_supported() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4566,8 +4569,8 @@ void test_user_credential_credential_learn_start_add_slot_not_supported() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4609,8 +4612,8 @@ void test_user_credential_credential_learn_start_add_type_not_supported() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4665,8 +4668,8 @@ void test_user_credential_credential_learn_start_add_credential_already_exists() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4709,8 +4712,8 @@ void test_user_credential_credential_learn_start_modify_happy_case() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4785,8 +4788,8 @@ void test_user_credential_credential_learn_start_modify_cl_not_supported() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4829,8 +4832,8 @@ void test_user_credential_credential_learn_start_modify_credential_not_existing( = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; std::vector supported_credential_slots = {1, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -4888,8 +4891,8 @@ void test_user_credential_uuic_association_same_slot_different_user() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {5, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -5013,8 +5016,8 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {5, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -5143,8 +5146,8 @@ void test_user_credential_uuic_association_different_slot_same_user() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {5, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, @@ -5260,8 +5263,8 @@ void test_user_credential_uuic_association_error_code() = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; std::vector supported_credential_slots = {5, 2}; - std::vector supported_cred_min_length = {2, 5}; - std::vector supported_cred_max_length = {6, 10}; + std::vector supported_cred_min_length = {2, 5}; + std::vector supported_cred_max_length = {6, 10}; std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, From bcbfd33f91d4df22f9912e23593e4dd6259279f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 31 Jul 2024 15:14:42 +0200 Subject: [PATCH 23/60] UIC-3222: Refactor User Get/Set/Report with new C++API May be squashed later with the full refactor of User Report according to the new Z-Wave specification --- .../zwave_command_class_user_credential.cpp | 576 ++++++++---------- ...ave_command_class_user_credential_test.cpp | 4 +- 2 files changed, 262 insertions(+), 318 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 7ee38c320..2377f9fbd 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -1915,13 +1915,9 @@ static sl_status_t zwave_command_class_user_credential_user_capabilities_get( { sl_log_debug(LOG_TAG, "User Capabilities Get"); - (void)node; // unused. - ZW_USER_CAPABILITIES_GET_FRAME *get_frame - = (ZW_USER_CAPABILITIES_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = USER_CAPABILITIES_GET; - *frame_length = sizeof(ZW_USER_CAPABILITIES_GET_FRAME); - return SL_STATUS_OK; + return frame_generator.generate_no_args_frame(USER_CAPABILITIES_GET, + frame, + frame_length); } sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( @@ -1929,100 +1925,57 @@ sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t INDEX_USER_COUNT = 2; - constexpr uint8_t INDEX_CREDENTIAL_RULES = 4; - constexpr uint8_t INDEX_MAX_LENGTH = 5; - constexpr uint8_t INDEX_SUPPORT_BITS = 6; - constexpr uint8_t INDEX_BITMASK_LENGTH = 7; - - if (frame_length < INDEX_BITMASK_LENGTH) { - return SL_STATUS_NOT_SUPPORTED; - } + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); sl_log_debug(LOG_TAG, "User Capabilities Report"); + const uint8_t expected_size = 9; - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); - - uint16_t user_count = get_uint16_value(frame_data, INDEX_USER_COUNT); - - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS), - &user_count, - sizeof(user_count)); + try { + zwave_frame_parser parser(frame_data, frame_length); - user_credential_supported_credential_rules_t credential_rules - = frame_data[INDEX_CREDENTIAL_RULES]; - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), - &credential_rules, - sizeof(credential_rules)); + if (!parser.is_frame_size_valid(expected_size, expected_size + 4)) { + sl_log_error(LOG_TAG, + "Invalid frame size for User Capabilities Report frame"); + return SL_STATUS_FAIL; + } - uint8_t max_length = frame_data[INDEX_MAX_LENGTH]; - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(MAX_USERNAME_LENGTH), - &max_length, - sizeof(max_length)); - - // Support bits - uint8_t support_bits = frame_data[INDEX_SUPPORT_BITS]; - // Create a lambda function that do what we want for all of the 3 parameters - auto emplace_bool_value = [&support_bits, - &endpoint_node](uint8_t bitmask, - attribute_store_type_t type) { - uint8_t bool_value = (support_bits & bitmask) > 0; - - attribute_store_set_child_reported(endpoint_node, - type, - &bool_value, - sizeof(bool_value)); - - // CL:0083.XX.XX.XX.X : If the All Users Checksum Support field is set in the User Capabilities Report Command, the controlling - // node SHOULD send an All Users Checksum Get Command to check if there are existing Users or - // Credentials present on the supporting node. - if (type == ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM) && bool_value) { + parser.read_sequential( + 2, + endpoint_node.emplace_node(ATTRIBUTE(NUMBER_OF_USERS))); + parser.read_byte( + endpoint_node.emplace_node(ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES))); + parser.read_byte( + endpoint_node.emplace_node(ATTRIBUTE(MAX_USERNAME_LENGTH))); + + constexpr uint8_t SUPPORT_ALL_USERS_CHECKSUM_BITMASK + = USER_CAPABILITIES_REPORT_PROPERTIES1_ALL_USERS_CHECKSUM_SUPPORT_BIT_MASK; + auto support_bits = parser.read_byte_with_bitmask( + {{USER_CAPABILITIES_REPORT_PROPERTIES1_USER_SCHEDULE_SUPPORT_BIT_MASK, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_USER_SCHEDULE))}, + {SUPPORT_ALL_USERS_CHECKSUM_BITMASK, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM))}, + {USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_USER_CHECKSUM))}}); + + // SUPPORT_ALL_USERS_CHECKSUM support + if (support_bits[SUPPORT_ALL_USERS_CHECKSUM_BITMASK]) { sl_log_debug(LOG_TAG, "SUPPORT_ALL_USERS_CHECKSUM is set, sending All Users " "Checksum Get Command"); - const attribute_store_type_t attributes[] = { - ATTRIBUTE(ALL_USERS_CHECKSUM), - }; - // Trigger get ALL_USERS_CHECKSUM - attribute_store_add_if_missing(endpoint_node, - attributes, - COUNT_OF(attributes)); + endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); } - }; - emplace_bool_value( - USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, - ATTRIBUTE(SUPPORT_USER_SCHEDULE)); - emplace_bool_value( - USER_CAPABILITIES_REPORT_PROPERTIES1_ALL_USERS_CHECKSUM_SUPPORT_BIT_MASK, - ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM)); - emplace_bool_value( - USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, - ATTRIBUTE(SUPPORT_USER_CHECKSUM)); - - // Bit mask support - user_credential_supported_user_type_bitmask_t bitmask = 0x0000; - uint8_t bitmask_length = frame_data[INDEX_BITMASK_LENGTH]; - // Since we are using uint32_t we can't have more that 4 bit mask - if (bitmask_length > 4) { + parser.read_bitmask( + endpoint_node.emplace_node(ATTRIBUTE(SUPPORTED_USER_TYPES))); + + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "user_credential_supported_user_type_bitmask_t length is not " - "supported\n"); - return SL_STATUS_NOT_SUPPORTED; - } - for (int i = bitmask_length; i > 0; i--) { - bitmask = (bitmask << 8) | frame_data[INDEX_BITMASK_LENGTH + i]; + "Error while parsing User Capabilities Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(SUPPORTED_USER_TYPES), - &bitmask, - sizeof(bitmask)); - return SL_STATUS_OK; } @@ -2041,7 +1994,6 @@ static sl_status_t ; } - sl_status_t zwave_command_class_user_credential_credential_capabilities_handle_report( const zwave_controller_connection_info_t *connection_info, @@ -2049,7 +2001,7 @@ sl_status_t uint16_t frame_length) { sl_log_debug(LOG_TAG, "Credential Capabilities Report"); - + attribute_store::attribute endpoint_node( zwave_command_class_get_endpoint_node(connection_info)); @@ -2059,10 +2011,10 @@ sl_status_t zwave_frame_parser parser(frame_data, frame_length); // We only needs to check the minimum size here - if (!parser.is_frame_size_valid(min_expected_size, - UINT8_MAX)) { - sl_log_error(LOG_TAG, - "Invalid frame size for Credential Capabilities Report frame"); + if (!parser.is_frame_size_valid(min_expected_size, UINT8_MAX)) { + sl_log_error( + LOG_TAG, + "Invalid frame size for Credential Capabilities Report frame"); return SL_STATUS_FAIL; } @@ -2129,29 +2081,31 @@ sl_status_t for (uint8_t current_credential_type_index = 0; current_credential_type_index < supported_credential_types_count; current_credential_type_index++) { - auto node = credential_type_nodes[current_credential_type_index].add_node(type); + auto node + = credential_type_nodes[current_credential_type_index].add_node(type); parser.read_byte(node); } }; create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH)); create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH)); - create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)); + create_and_store_uint8_value( + ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)); create_and_store_uint8_value(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS)); - // Set UCL mask for supported user credential types endpoint_node .emplace_node( DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES) .set_reported(ucl_credential_type_mask); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while parsing Credential Capabilities Report frame : %s", - e.what()); + } catch (const std::exception &e) { + sl_log_error( + LOG_TAG, + "Error while parsing Credential Capabilities Report frame : %s", + e.what()); return SL_STATUS_FAIL; } - return SL_STATUS_OK; + return SL_STATUS_OK; } ///////////////////////////////////////////////////////////////////////////// @@ -3404,120 +3358,124 @@ void trigger_get_user(attribute_store_node_t endpoint_node, } static sl_status_t zwave_command_class_user_credential_user_set( - attribute_store_node_t user_operation_type_node, - uint8_t *frame, - uint16_t *frame_length) + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - // Get user unique id node - attribute_store_node_t user_unique_id_node - = attribute_store_get_first_parent_with_type(user_operation_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); - - user_credential_user_unique_id_t user_id = 0; - attribute_store_get_desired_else_reported(user_unique_id_node, - &user_id, - sizeof(user_id)); - - // If we can't get the user unique id we can't continue - if (!attribute_store_node_exists(user_unique_id_node)) { - return SL_STATUS_NOT_SUPPORTED; - } + try { + // Node setup + attribute_store::attribute user_operation_type_node(node); + attribute_store::attribute user_unique_id_node + = user_operation_type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + // Get Values + auto user_unique_id + = user_unique_id_node + .desired_or_reported(); + auto user_operation_type + = user_operation_type_node.desired(); + + const bool is_delete_operation + = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); + + uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; + uint8_t user_name_size = 0; + + if (!is_delete_operation) { + user_name_size = static_cast( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) + .reported() + .size()); + } - user_credential_operation_type_t user_operation_type = 0; - sl_status_t status = attribute_store_get_desired(user_operation_type_node, - &user_operation_type, - sizeof(user_operation_type)); + // Append the user name size (will be 0 if is delete operation) + expected_frame_size += user_name_size; - sl_log_debug(LOG_TAG, - "User SET for user %d (operation type : %d)", - user_id, - user_operation_type); + sl_log_debug(LOG_TAG, + "User SET for user %d (operation type : %d)", + user_unique_id, + user_operation_type); + + // Creating the frame + frame_generator.initialize_frame(USER_SET, frame, expected_frame_size); + + frame_generator.add_value(user_operation_type_node, DESIRED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + + if (!is_delete_operation) { + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_TYPE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_ACTIVE_STATE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_RULE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node.child_by_type( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME_ENCODING)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_raw_byte(user_name_size); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)), + DESIRED_OR_REPORTED_ATTRIBUTE); + } - if (status != SL_STATUS_OK) { + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't get user operation type value. Not sending USER_SET."); - return SL_STATUS_NOT_SUPPORTED; - } - - std::vector set_data - = {{ATTRIBUTE(USER_OPERATION_TYPE), DESIRED_ATTRIBUTE}, - {ATTRIBUTE(USER_UNIQUE_ID), - DESIRED_OR_REPORTED_ATTRIBUTE, - user_unique_id_node}}; - - // If we are not deleting the user we need more data - if (user_operation_type != USER_SET_OPERATION_TYPE_DELETE) { - std::vector extra_set_data = { - {ATTRIBUTE(USER_TYPE), DESIRED_OR_REPORTED_ATTRIBUTE}, - {ATTRIBUTE(USER_ACTIVE_STATE), DESIRED_OR_REPORTED_ATTRIBUTE}, - {ATTRIBUTE(CREDENTIAL_RULE), DESIRED_OR_REPORTED_ATTRIBUTE}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), DESIRED_OR_REPORTED_ATTRIBUTE}, - {ATTRIBUTE(USER_NAME_ENCODING), DESIRED_OR_REPORTED_ATTRIBUTE}, - {ATTRIBUTE(USER_NAME), DESIRED_OR_REPORTED_ATTRIBUTE}, - }; - std::copy(extra_set_data.begin(), - extra_set_data.end(), - std::back_inserter(set_data)); - } - - status = create_command_frame(USER_SET, - set_data, - user_unique_id_node, - frame, - frame_length); - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Can't create User SET frame"); + "Error while generating User SET frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - return SL_STATUS_OK; } static sl_status_t zwave_command_class_user_credential_user_get( attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - user_credential_user_unique_id_t user_id = 0; - sl_status_t status - = attribute_store_get_desired(node, &user_id, sizeof(user_id)); + attribute_store::attribute user_unique_id_node(node); // If we enter this state it means that something went badly wrong or // user initiate the interview process again. // In both cases we want to invalidate the user database so that the device // can send us the correct user database. - if (status != SL_STATUS_OK) { + + if (!user_unique_id_node.desired_exists()) { sl_log_warning(LOG_TAG, - "Can't get user unique id value. Reset user database."); - attribute_store_node_t endpoint_node - = attribute_store_get_node_parent(node); + "Can't get user unique id Desired value. Removing all users " + "to perform interview again."); + attribute_store::attribute endpoint_node = user_unique_id_node.parent(); + // Get User node count - auto user_count - = attribute_store_get_node_child_count_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID)); - - for (size_t j = 0; j < user_count; j++) { - // Delete the first attribute we find until we have no more left - attribute_store_node_t user_node - = attribute_store_get_node_child_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - 0); + for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { attribute_store_delete_node(user_node); } + // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. return SL_STATUS_NOT_SUPPORTED; } + user_credential_user_unique_id_t user_id + = user_unique_id_node.desired(); sl_log_debug(LOG_TAG, "User Get for user %d", user_id); - auto exploded_value = explode_uint16(user_id); - - ZW_USER_GET_FRAME *get_frame = (ZW_USER_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = USER_GET; - get_frame->userUniqueIdentifier1 = exploded_value.msb; - get_frame->userUniqueIdentifier2 = exploded_value.lsb; + // Generate the frame + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_GET_FRAME)); + try { + frame_generator.initialize_frame(USER_GET, frame, expected_frame_size); + frame_generator.add_value(user_unique_id_node, DESIRED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating USER_GET frame : %s", + e.what()); + return SL_STATUS_FAIL; + } - *frame_length = sizeof(ZW_USER_GET_FRAME); return SL_STATUS_OK; } @@ -3526,152 +3484,140 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t INDEX_NEXT_USER_ID = 2; - constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 4; - constexpr uint8_t INDEX_USER_MODIFIER_ID = 5; - constexpr uint8_t INDEX_USER_ID = 7; - constexpr uint8_t INDEX_USER_TYPE = 9; - constexpr uint8_t INDEX_USER_ACTIVE_STATE = 10; - constexpr uint8_t INDEX_CREDENTIAL_RULE = 11; - constexpr uint8_t INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES = 12; - constexpr uint8_t INDEX_USER_NAME_ENCODING = 14; - constexpr uint8_t INDEX_USER_NAME_LENGTH = 15; - constexpr uint8_t INDEX_USER_NAME = 16; - - if (frame_length < INDEX_USER_NAME) { - return SL_STATUS_NOT_SUPPORTED; - } + sl_log_debug(LOG_TAG, "User Report"); - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - // Find the user - const user_credential_user_unique_id_t user_id - = get_uint16_value(frame_data, INDEX_USER_ID); + const uint8_t expected_min_size = 16; - sl_log_debug(LOG_TAG, "User report for user %d", user_id); + try { + zwave_frame_parser parser(frame_data, frame_length); - auto remove_node_0_if_exists = [&]() { - attribute_store_node_t node_0; - get_user_id_node(endpoint_node, 0, DESIRED_ATTRIBUTE, node_0); - return attribute_store_delete_node(node_0); - }; + if (!parser.is_frame_size_valid(expected_min_size, UINT8_MAX)) { + sl_log_error(LOG_TAG, "Invalid frame size for User Report frame"); + return SL_STATUS_FAIL; + } - // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node - if (user_id == 0) { - sl_log_info(LOG_TAG, - "User report with ID 0 received. This probably means that no " - "user is defined on the device."); - sl_log_debug(LOG_TAG, - "Attempt to delete User Node ID with value %d", - user_id); - sl_status_t deletion_status = remove_node_0_if_exists(); - sl_log_debug(LOG_TAG, "Deletion returned status : %d", deletion_status); - return SL_STATUS_OK; - } + //parser.read_byte(); // TODO : use User Report Type; - // Get User ID node - attribute_store_node_t user_unique_id_node; + auto next_user_id + = parser.read_sequential(2); - // First we check if there this user already exists in our database (reported value) - if (!get_user_id_node(endpoint_node, - user_id, - REPORTED_ATTRIBUTE, - user_unique_id_node)) { - sl_log_debug(LOG_TAG, - "Could not find user %d with reported value, trying desired", - user_id); - // If User node doesn't exists with given desired attribute - if (!get_user_id_node(endpoint_node, - user_id, - DESIRED_ATTRIBUTE, - user_unique_id_node)) { - sl_log_debug( - LOG_TAG, - "Could not find user %d with desired value, using the User ID 0", - user_id); + user_credential_modifier_type_t user_modifier_type = parser.read_byte(); + auto user_modifier_id + = parser.read_sequential(2); - // If not found it will be checked in the next step - get_user_id_node(endpoint_node, - 0, - DESIRED_ATTRIBUTE, - user_unique_id_node); + // Get User ID + auto current_user_id + = parser.read_sequential(2); + + sl_log_debug(LOG_TAG, "User report for user %d", current_user_id); + + auto remove_node_0_if_exists = [&]() { + attribute_store_node_t node_0; + get_user_id_node(endpoint_node, 0, DESIRED_ATTRIBUTE, node_0); + return attribute_store_delete_node(node_0); + }; + + // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node + if (current_user_id == 0) { + sl_log_info(LOG_TAG, + "User report with ID 0 received. This probably means that no " + "user is defined on the device."); + sl_log_debug(LOG_TAG, + "Attempt to delete User Node ID with value %d", + current_user_id); + sl_status_t deletion_status = remove_node_0_if_exists(); + sl_log_debug(LOG_TAG, "Deletion returned status : %d", deletion_status); + return SL_STATUS_OK; } - } - // Check node existence - if (!attribute_store_node_exists(user_unique_id_node)) { - sl_log_error(LOG_TAG, "Can't find user with ID %d in USER_REPORT", user_id); - return SL_STATUS_NOT_SUPPORTED; - } + // Find user id + auto current_user_id_node + = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + if (!current_user_id_node.is_valid()) { + sl_log_debug(LOG_TAG, + "Could not find user %d with reported value, trying desired", + current_user_id); + // If User node doesn't exists with given desired attribute + current_user_id_node = endpoint_node.child_by_type_and_value_desired( + ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + + if (!current_user_id_node.is_valid()) { + sl_log_debug( + LOG_TAG, + "Could not find user %d with desired value, using the User ID 0", + current_user_id); + current_user_id_node = endpoint_node.child_by_type_and_value_desired< + user_credential_user_unique_id_t>(ATTRIBUTE(USER_UNIQUE_ID), 0); + } + } - // Check if user still exists - if (frame_data[INDEX_USER_MODIFIER_TYPE] == USER_REPORT_DNE) { - sl_log_debug( - LOG_TAG, - "User %d does not exist anymore, removing from attribute store.", - user_id); - attribute_store_delete_node(user_unique_id_node); - return SL_STATUS_OK; - } + // Check node existence + if (!current_user_id_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d in USER_REPORT", + current_user_id); + return SL_STATUS_NOT_SUPPORTED; + } - // Set reported value - attribute_store_set_reported(user_unique_id_node, &user_id, sizeof(user_id)); - attribute_store_undefine_desired(user_unique_id_node); + if (user_modifier_type == USER_REPORT_DNE) { + sl_log_debug( + LOG_TAG, + "User %d does not exist anymore, removing from attribute store.", + current_user_id); + attribute_store_delete_node(current_user_id_node); + return SL_STATUS_OK; + } - // Remove leftover of node 0 if it exists - // This is necessary if we are interviewing again the user as this node will be left undefined - // and causing a get loop. - remove_node_0_if_exists(); + // Everything is fine, set the reported value to the current user id node + current_user_id_node.set_reported(current_user_id); + current_user_id_node.clear_desired(); - // Set standard (uint8 & uint16) data - std::vector user_data - = {{ATTRIBUTE(USER_MODIFIER_TYPE), INDEX_USER_MODIFIER_TYPE}, - {ATTRIBUTE(USER_MODIFIER_NODE_ID), INDEX_USER_MODIFIER_ID}, - {ATTRIBUTE(USER_TYPE), INDEX_USER_TYPE}, - {ATTRIBUTE(USER_ACTIVE_STATE), - INDEX_USER_ACTIVE_STATE, - USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK}, - {ATTRIBUTE(USER_NAME_ENCODING), - INDEX_USER_NAME_ENCODING, - USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK}, - {ATTRIBUTE(CREDENTIAL_RULE), INDEX_CREDENTIAL_RULE}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - INDEX_USER_NAME_EXPIRING_TIMEOUT_MINUTES}}; + // Remove leftover of node 0 if it exists + // This is necessary if we are interviewing again the user as this node will be left undefined + // and causing a get loop. + remove_node_0_if_exists(); - sl_status_t set_status - = set_reported_attributes(user_unique_id_node, frame_data, user_data); + // Set already parsed values + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) + .set_reported(user_modifier_type); + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_NODE_ID)) + .set_reported(user_modifier_id); - if (set_status != SL_STATUS_OK) { - return set_status; - } + // Keep parsing the frame + parser.read_byte(current_user_id_node.emplace_node(ATTRIBUTE(USER_TYPE))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE))}); + parser.read_byte( + current_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE))); + parser.read_sequential( + 2, + current_user_id_node.emplace_node( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING))}); + parser.read_string(current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME))); - // User name - uint8_t user_name_length = frame_data[INDEX_USER_NAME_LENGTH]; - std::string user_name - = get_string_value(frame_data, INDEX_USER_NAME, user_name_length); + // Get credentials + trigger_get_credential(current_user_id_node, 0, 0); - // Prevent duplicate - auto user_name_node - = attribute_store_get_first_child_by_type(user_unique_id_node, - ATTRIBUTE(USER_NAME)); - if (!attribute_store_node_exists(user_name_node)) { - user_name_node - = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_unique_id_node); - } - attribute_store_set_reported_string(user_name_node, user_name.c_str()); - - // Get credentials - trigger_get_credential(user_unique_id_node, 0, 0); - - // Interview next ID if needed - user_credential_user_unique_id_t next_user_id - = get_uint16_value(frame_data, INDEX_NEXT_USER_ID); - if (next_user_id != 0) { - sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); - trigger_get_user(endpoint_node, next_user_id); - } else { - sl_log_debug(LOG_TAG, "No more users to discover"); + if (next_user_id != 0) { + sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); + trigger_get_user(endpoint_node, next_user_id); + } else { + sl_log_debug(LOG_TAG, "No more users to discover"); + } + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } return SL_STATUS_OK; diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 20384cf5b..f662664b6 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1819,15 +1819,13 @@ void test_user_credential_user_report_happy_case() test_user_values(second_user_id_node); // Test structure - // The report function should not have created an other user unique id node (next_user_id = 0) user_id_count = attribute_store_get_node_child_count_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID)); TEST_ASSERT_EQUAL_MESSAGE(2, user_id_count, - "User node count mismatch. Should be 2 : 1 for " - "the reported one and 1 for the next one"); + "User node count mismatch. Should only 2 users created."); user_credential_user_unique_id_t reported_id; attribute_store_get_reported(first_user_id_node, From 5a097af4e9ccacfc709aa9989f028978b6e65e51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 1 Aug 2024 16:04:55 +0200 Subject: [PATCH 24/60] UIC-3222: CREDENTIAL_DATA doesn't rely on CREDENTIAL_DATA_LENGTH anymore This length is deducted from the attribute itself no need to complicate things. --- .../user_credential_cluster_server_test.cpp | 37 +-- .../attribute_store_defined_attribute_types.h | 42 ++- .../zpc_attribute_store_type_registration.cpp | 3 +- .../zwave_command_class_user_credential.cpp | 311 ++++++------------ ...ave_command_class_user_credential_test.cpp | 87 +---- 5 files changed, 145 insertions(+), 335 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index cf625ea13..366d94dc3 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -14,6 +14,7 @@ // Cpp #include #include "workaround_for_test.hpp" +#include "attribute.hpp" extern "C" { #include "user_credential_cluster_server.h" @@ -781,13 +782,6 @@ attribute_store_node_t cpp_str_credential_data.end()); } - uint8_t credential_data_length = credential_data_vector.size(); - attribute_store_node_t credential_data_length_node - = attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &credential_data_length, - sizeof(credential_data_length)); - mock_expected_cred_mqtt_topic( user_id, credential_type, @@ -795,7 +789,7 @@ attribute_store_node_t "CredentialData", // Credential data is published in UTF-8 no matter what the encoding is cpp_str_credential_data); - attribute_store_emplace(credential_data_length_node, + attribute_store_emplace(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data_vector.data(), credential_data_vector.size()); @@ -973,7 +967,6 @@ void helper_test_desired_credential_attributes( reported_credential_slot, "Credential Slot mismatch"); - uint8_t expected_data_length; std::vector expected_credential_data_vector; std::string str_credential_data(credential_data); @@ -988,35 +981,19 @@ void helper_test_desired_credential_attributes( expected_credential_data_vector.push_back((uint8_t)(c >> 8)); expected_credential_data_vector.push_back((uint8_t)c); } - expected_data_length = expected_credential_data_vector.size(); } else { - expected_data_length = str_credential_data.size(); expected_credential_data_vector = std::vector(str_credential_data.begin(), str_credential_data.end()); } - // Credential Data Length - attribute_store_node_t credential_data_length_node - = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); - uint8_t reported_credential_data_length; - attribute_store_get_desired(credential_data_length_node, - &reported_credential_data_length, - sizeof(reported_credential_data_length)); - TEST_ASSERT_EQUAL_MESSAGE(expected_data_length, - reported_credential_data_length, - "Credential Data Length mismatch"); // Credential Data - attribute_store_node_t credential_data_node - = attribute_store_get_first_child_by_type(credential_data_length_node, + attribute_store::attribute credential_data_node + = attribute_store_get_first_child_by_type(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA)); - std::vector reported_credential_data; - reported_credential_data.resize(reported_credential_data_length); - attribute_store_get_desired(credential_data_node, - reported_credential_data.data(), - reported_credential_data_length); + std::vector reported_credential_data + = credential_data_node + .desired>(); TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_credential_data_vector.data(), reported_credential_data.data(), diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index b91faa23c..534209938 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1181,59 +1181,57 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, /// > Credentials DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1A)) -DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) // Specific to Credential SET DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x21)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) // Specific to USER SET DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x22)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x21)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x22)) // Specific to Credential Learn DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x24)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x24)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) // Specific to Credential User Unique Identifier Credential (UUIC) Association DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x29)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2A)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x29)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2A)) // Checksums DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM_MISMATCH_ERROR, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2F)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) ///////////////////////////////////////////////// // Z-Wave Plus Info CC diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index 0be000dfc..c66ca7578 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -502,8 +502,7 @@ static const std::vector attribute_schema = { // Credential {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, "User Credential Credential Type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, "User Credential Credential Slot", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, "User Credential Credential Data Length", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, - {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, "User Credential Credential Data", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA_LENGTH, BYTE_ARRAY_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, "User Credential Credential Data", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, BYTE_ARRAY_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, "User Credential Credential Read Back Flag", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, "User Credential Credential Modifier type", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, "User Credential Credential Node ID", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, U16_STORAGE_TYPE}, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 2377f9fbd..59095ea57 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -121,6 +121,31 @@ struct attribute_command_data { attribute_store_node_t node = ATTRIBUTE_STORE_INVALID_NODE; }; +struct credential_nodes { + attribute_store::attribute slot_node; + attribute_store::attribute type_node; + attribute_store::attribute user_unique_id_node; +}; + +/** + * @brief + * @param node + * @return + */ +credential_nodes get_credential_nodes(attribute_store_node_t node) +{ + attribute_store::attribute slot_node(node); + slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store::attribute type_node + = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); + attribute_store::attribute user_unique_id_node + = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + return {.slot_node = slot_node, + .type_node = type_node, + .user_unique_id_node = user_unique_id_node}; +} + ///////////////////////////////////////////////////////////////////////////// // Capabilites Data Structs ///////////////////////////////////////////////////////////////////////////// @@ -905,20 +930,9 @@ sl_status_t node_to_uint8_vector(attribute_store_node_t node, // Variable length field case BYTE_ARRAY_STORAGE_TYPE: { // First get the length - auto credential_length_node = attribute_store_get_node_parent(node); - - uint8_t credential_data_length = 0; - status = attribute_store_read_value(credential_length_node, - value_state, - &credential_data_length, - sizeof(credential_data_length)); - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Missing BYTE_ARRAY_STORAGE_TYPE length for attribute %s", - attribute_description); - return SL_STATUS_NOT_SUPPORTED; - } + auto credential_data_length + = attribute_store_get_node_value_size(node, value_state); + // + 1 for the length data.resize(credential_data_length + 1); data[0] = credential_data_length; @@ -1352,7 +1366,6 @@ void update_credential_reported_values( 7}, {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), INDEX_CREDENTIAL_MODIFIER_TYPE}, {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), INDEX_CREDENTIAL_MODIFIER_NODE_ID}, - {ATTRIBUTE(CREDENTIAL_DATA_LENGTH), INDEX_CREDENTIAL_LENGTH}, }; sl_status_t status = set_reported_attributes(credential_slot_node, @@ -1364,11 +1377,8 @@ void update_credential_reported_values( return; } - auto credential_data_length_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); auto credential_data_node - = attribute_store_get_first_child_by_type(credential_data_length_node, + = attribute_store_get_first_child_by_type(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA)); status @@ -2215,176 +2225,99 @@ void trigger_get_credential(attribute_store_node_t user_unique_id_node, } } -static sl_status_t zwave_command_class_user_credential_credential_set( +sl_status_t zwave_command_class_user_credential_credential_set( attribute_store_node_t credential_operation_type_node, uint8_t *frame, uint16_t *frame_length) { - // Identifiers nodes - attribute_store_node_t credential_slot_node - = attribute_store_get_first_parent_with_type(credential_operation_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - attribute_store_node_t credential_type_node - = attribute_store_get_first_parent_with_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - attribute_store_node_t user_unique_id_node - = attribute_store_get_first_parent_with_type(credential_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); + sl_log_debug(LOG_TAG, "Credential Set"); + try { + credential_nodes cred_nodes + = get_credential_nodes(credential_operation_type_node); - // Since CREDENTIAL_DATA is not directly under credential_slot_node we need to fetch it first - attribute_store_node_t credential_length_node - = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); - attribute_store_node_t credential_node - = attribute_store_get_first_child_by_type(credential_length_node, - ATTRIBUTE(CREDENTIAL_DATA)); - // Get operation type - user_credential_operation_type_t operation_type = 0; - sl_status_t status - = attribute_store_get_desired(credential_operation_type_node, - &operation_type, - sizeof(operation_type)); + auto operation_type + = cred_nodes.slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_OPERATION_TYPE)) + .desired(); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get operation type. Not sending CREDENTIAL_SET."); - return SL_STATUS_NOT_SUPPORTED; - } + sl_log_debug(LOG_TAG, "Operation type : %d", operation_type); - sl_log_debug(LOG_TAG, - "Credential SET for Credential Slot %d, Credential Type %d, " - "User %d (operation type : %d)", - static_cast( - attribute_store_get_reported_number(credential_slot_node)), - static_cast( - attribute_store_get_reported_number(credential_type_node)), - static_cast( - attribute_store_get_reported_number(user_unique_id_node)), - operation_type); + // Generate the frame + const bool is_delete_operation + = (operation_type == CREDENTIAL_SET_OPERATION_TYPE_DELETE); - // Since the data is not linear we provide the node directly - std::vector set_data - = {{ATTRIBUTE(USER_UNIQUE_ID), - DESIRED_OR_REPORTED_ATTRIBUTE, - user_unique_id_node}, - {ATTRIBUTE(CREDENTIAL_TYPE), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_type_node}, - {ATTRIBUTE(CREDENTIAL_SLOT), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_slot_node}, - {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - DESIRED_ATTRIBUTE, - credential_operation_type_node}}; + uint8_t expected_frame_size = 9; + uint8_t credential_size = 0; + auto credential_data_node + = cred_nodes.slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA)); - // Add the credential data if we are not trying to remove a credential - if (operation_type != USER_CREDENTIAL_OPERATION_TYPE_DELETE) { - set_data.push_back({ATTRIBUTE(CREDENTIAL_DATA), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_node}); - } - status = create_command_frame(CREDENTIAL_SET, - set_data, - credential_slot_node, - frame, - frame_length); + if (!is_delete_operation) { + auto state = REPORTED_ATTRIBUTE; + if (credential_data_node.desired_exists()) { + state = DESIRED_ATTRIBUTE; + } + credential_size = static_cast( + credential_data_node.get>(state).size()); + } - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Can't create Credential SET frame"); + // Append the credential data + expected_frame_size += credential_size; + + frame_generator.initialize_frame(CREDENTIAL_SET, + frame, + expected_frame_size); + frame_generator.add_value(cred_nodes.user_unique_id_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(cred_nodes.type_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(cred_nodes.slot_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_raw_byte(operation_type); + frame_generator.add_raw_byte(credential_size); + if (!is_delete_operation) { + frame_generator.add_value(credential_data_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + } + + frame_generator.validate_frame(frame_length); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating Credential Set frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - // If we are deleting the credential we are setting 0x00 as a credential length - if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_DELETE) { - frame[*frame_length] = 0x00; - *frame_length += 1; - } return SL_STATUS_OK; } -/** - * @brief Credential GET - * - * Attribute store IN : - * CREDENTIAL_TYPE : desired value => get_frame->credentialType - * CREDENTIAL_SLOT : desired value => get_frame->credentialSlot1 & credentialSlot2 - * USER_UNIQUE_ID : reported value => get_frame->userUniqueIdentifier1 & userUniqueIdentifier2 - * - * Attribute store OUT : - * CREDENTIAL_TYPE : set reported as desired & clear desired - * CREDENTIAL_SLOT : set reported as desired & clear desired - * - * @param credential_slot_node - * @param frame - * @param frame_length - * @return sl_status_t - */ static sl_status_t zwave_command_class_user_credential_credential_get( attribute_store_node_t credential_slot_node, uint8_t *frame, uint16_t *frame_length) { - user_credential_slot_t credential_slot = 0; - sl_status_t status = attribute_store_get_desired(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't get credential slot value. Not sending CREDENTIAL_GET."); - return SL_STATUS_NOT_SUPPORTED; - } + sl_log_debug(LOG_TAG, "Credential Get"); - // Get Credential type - user_credential_type_t credential_type = 0; - attribute_store_node_t credential_type_node - = attribute_store_get_first_parent_with_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - status = attribute_store_get_reported(credential_type_node, - &credential_type, - sizeof(credential_type)); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get credential_type. Not sending CREDENTIAL_GET."); - return SL_STATUS_NOT_SUPPORTED; - } + credential_nodes cred_nodes = get_credential_nodes(credential_slot_node); - // Get User Node - attribute_store_node_t user_unique_id_node - = attribute_store_get_first_parent_with_type(credential_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); - user_credential_user_unique_id_t user_unique_id; - status = attribute_store_get_reported(user_unique_id_node, - &user_unique_id, - sizeof(user_unique_id)); - if (status != SL_STATUS_OK) { + // Generate the frame + constexpr auto expected_frame_size + = static_cast(sizeof(ZW_CREDENTIAL_GET_FRAME)); + try { + frame_generator.initialize_frame(CREDENTIAL_GET, + frame, + expected_frame_size); + frame_generator.add_value(cred_nodes.user_unique_id_node, + REPORTED_ATTRIBUTE); + frame_generator.add_value(cred_nodes.type_node, REPORTED_ATTRIBUTE); + frame_generator.add_value(cred_nodes.slot_node, DESIRED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't get user_unique_id. Not sending CREDENTIAL_GET."); + "Error while generating Credential Get frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - // Log credential node, type, and user ID - sl_log_debug( - LOG_TAG, - "Credential Get. Credential slot: %d / Credential Type: %d (User %d)", - credential_slot, - credential_type, - user_unique_id); - - auto exploded_credential_slot = explode_uint16(credential_slot); - auto exploded_user_id = explode_uint16(user_unique_id); - - ZW_CREDENTIAL_GET_FRAME *get_frame = (ZW_CREDENTIAL_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = CREDENTIAL_GET; - get_frame->userUniqueIdentifier1 = exploded_user_id.msb; - get_frame->userUniqueIdentifier2 = exploded_user_id.lsb; - get_frame->credentialType = credential_type; - get_frame->credentialSlot1 = exploded_credential_slot.msb; - get_frame->credentialSlot2 = exploded_credential_slot.lsb; - - *frame_length = sizeof(ZW_CREDENTIAL_GET_FRAME); return SL_STATUS_OK; } @@ -2567,21 +2500,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return status; } - // Set credential data - auto credential_data_length_node - = attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &credential_length, - sizeof(credential_length)); - - if (credential_data_length_node == ATTRIBUTE_STORE_INVALID_NODE) { - sl_log_error(LOG_TAG, - "Can't set CREDENTIAL_DATA_LENGTH in attribute store"); - return SL_STATUS_NOT_SUPPORTED; - } - status - = attribute_store_set_child_reported(credential_data_length_node, + = attribute_store_set_child_reported(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), &frame_data[INDEX_CREDENTIAL_DATA], credential_length); @@ -3890,12 +3810,8 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( return SL_STATUS_FAIL; } - auto credential_data_length_node - = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); auto credential_data_node - = attribute_store_get_first_child_by_type(credential_data_length_node, + = attribute_store_get_first_child_by_type(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA)); // Add credential data to checksum @@ -4056,12 +3972,8 @@ sl_status_t return SL_STATUS_FAIL; } - auto credential_data_length_node - = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); auto credential_data_node - = attribute_store_get_first_child_by_type(credential_data_length_node, + = attribute_store_get_first_child_by_type(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA)); // Add credential data to checksum @@ -4518,14 +4430,7 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( sizeof(credential_slot)); // Add data - uint8_t data_size = credential_data_vector.size(); - auto credential_data_length_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &data_size, - sizeof(data_size)); - - attribute_store_emplace_desired(credential_data_length_node, + attribute_store_emplace_desired(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data_vector.data(), credential_data_vector.size()); @@ -4614,24 +4519,8 @@ sl_status_t zwave_command_class_user_credential_modify_credential( } // Add data - uint8_t data_size = credential_data_vector.size(); - - auto credential_data_length_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); - - if (!attribute_store_node_exists(credential_data_length_node)) { - sl_log_error(LOG_TAG, - "Can't find CREDENTIAL_DATA_LENGTH in attribute store. Not " - "modifying credential."); - return SL_STATUS_FAIL; - } - attribute_store_set_desired(credential_data_length_node, - &data_size, - sizeof(data_size)); - sl_status_t status - = attribute_store_set_child_desired(credential_data_length_node, + = attribute_store_set_child_desired(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data_vector.data(), credential_data_vector.size()); diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index f662664b6..3c0cf47f8 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -12,6 +12,7 @@ *****************************************************************************/ #include #include "workaround_for_test.hpp" +#include "attribute.hpp" extern "C" { @@ -31,6 +32,7 @@ extern "C" { #include "attribute_store_type_registration.h" #include "zpc_attribute_store_type_registration.h" + // Interface includes #include "attribute_store_defined_attribute_types.h" #include "ZW_classcmd.h" @@ -47,6 +49,7 @@ extern "C" { #include "dotdot_mqtt_mock.h" #include "dotdot_mqtt_generated_commands_mock.h" #include "zwave_command_class_notification_mock.h" + // Used for delayed interview #include "zwave_network_management_mock.h" @@ -622,18 +625,8 @@ void helper_test_set_get_with_args( } break; // Variable length field case BYTE_ARRAY_STORAGE_TYPE: { - // Length node should be a parent of the data node - auto data_length_node = attribute_store_get_node_parent(node); - - uint8_t data_length = 0; - attribute_store_read_value(data_length_node, - node_value_state, - &data_length, - sizeof(data_length)); - if (data_length == 0) { - TEST_FAIL_MESSAGE( - "Can't get data_length for BYTE_ARRAY_STORAGE_TYPE type"); - } + uint8_t data_length + = attribute_store_get_node_value_size(node, node_value_state); std::vector data; data.resize(data_length); @@ -832,14 +825,7 @@ void helper_fill_credential_data(attribute_store_node_t credential_slot_node, std::string credential_data, user_credential_modifier_type_t modifier_type) { - uint8_t credential_data_length = credential_data.size(); - auto credential_data_length_node - = attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &credential_data_length, - sizeof(uint8_t)); - - attribute_store_emplace(credential_data_length_node, + attribute_store_emplace(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data.data(), credential_data.size()); @@ -849,29 +835,14 @@ void helper_fill_credential_data(attribute_store_node_t credential_slot_node, &modifier_type, sizeof(modifier_type)); } -void helper_test_credential_data(attribute_store_node_t credential_slot_node, + +void helper_test_credential_data(attribute_store::attribute credential_slot_node, std::string credential_data, user_credential_modifier_type_t modifier_type) { - uint8_t credential_data_length = credential_data.size(); - auto credential_data_length_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); - uint8_t reported_credential_data_length; - attribute_store_get_reported(credential_data_length_node, - &reported_credential_data_length, - sizeof(reported_credential_data_length)); - TEST_ASSERT_EQUAL_MESSAGE(credential_data_length, - reported_credential_data_length, - "Credential data length mismatch"); - - std::vector reported_credential_data; - reported_credential_data.resize(reported_credential_data_length); - - attribute_store_get_child_reported(credential_data_length_node, - ATTRIBUTE(CREDENTIAL_DATA), - reported_credential_data.data(), - reported_credential_data_length); + auto reported_credential_data + = credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA)) + .reported>(); TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(credential_data.data(), reported_credential_data.data(), @@ -1974,15 +1945,8 @@ void test_user_credential_credential_set_1byte_happy_case() &operation_type, sizeof(operation_type)); // CREDENTIAL_DATA - uint8_t credential_data_length = credential_data.size(); - auto credential_data_length_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &credential_data_length, - sizeof(uint8_t)); - auto credential_data_node - = attribute_store_emplace_desired(credential_data_length_node, + = attribute_store_emplace_desired(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data.data(), credential_data.size()); @@ -2023,15 +1987,8 @@ void test_user_credential_credential_set_12byte_happy_case() &operation_type, sizeof(operation_type)); // CREDENTIAL_DATA - uint8_t credential_data_length = credential_data.size(); - auto credential_data_length_node - = attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH), - &credential_data_length, - sizeof(uint8_t)); - auto credential_data_node - = attribute_store_emplace(credential_data_length_node, + = attribute_store_emplace(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), credential_data.data(), credential_data.size()); @@ -2279,21 +2236,12 @@ void test_user_credential_credential_report_happy_case() helper_test_attribute_store_values(uint16_attribute_map, credential_slot_node); - auto credential_length_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA_LENGTH)); - uint8_t reported_credential_length; - attribute_store_get_reported(credential_length_node, - &reported_credential_length, - sizeof(reported_credential_length)); - TEST_ASSERT_EQUAL_MESSAGE(credential_data.size(), - reported_credential_length, - "Credential data length value mismatch"); - + + size_t reported_credential_length = credential_data.size(); std::vector reported_credential_data; reported_credential_data.resize(reported_credential_length); - attribute_store_get_child_reported(credential_length_node, + attribute_store_get_child_reported(credential_slot_node, ATTRIBUTE(CREDENTIAL_DATA), reported_credential_data.data(), reported_credential_length); @@ -3128,8 +3076,7 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() credential_type_node); uint8_attribute_map - = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}, - {ATTRIBUTE(CREDENTIAL_DATA_LENGTH), credential_data.size()}}; + = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}}; helper_test_attribute_store_values(uint8_attribute_map, credential_slot_node); From bdad2998b62b846d8fbadcb1522fb73d8df8a928 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 20 Aug 2024 15:20:04 +0200 Subject: [PATCH 25/60] UIC-3222: New specification of User Report Fix delete all user in report user Remove notification handler for user --- .../zwave_command_class_user_credential.cpp | 556 ++++++++---------- ...ave_command_class_user_credential_test.cpp | 278 +++++---- 2 files changed, 395 insertions(+), 439 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 59095ea57..3bff12cde 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -43,6 +43,7 @@ #include #include #include +#include // Cpp Attribute store #include "attribute.hpp" @@ -558,6 +559,8 @@ void set_credential_learn_operation_type( /** * @brief Get user id node * + * @deprecated + * * @warning state can't be DESIRED_OR_REPORTED_ATTRIBUTE or it will not work * * @param endpoint_node Endpoint point node @@ -587,6 +590,8 @@ bool get_user_id_node(attribute_store_node_t endpoint_node, /** * @brief Get node associated with user ID (reported) * + * @deprecated + * * @warning This function only checks the reported User Unique * * @param endpoint_node Current endpoint node @@ -609,6 +614,8 @@ attribute_store_node_t * * @warning This function only checks the reported User Unique * + * @deprecated + * * @param endpoint_node Current endpoint node * @param user_id User ID * @@ -624,9 +631,132 @@ attribute_store_node_t return user_id_node; } +/** + * @brief Get node associated with user ID (desired or reported) + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * + * @return True is user exists, false otherwise + */ +bool user_exists(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id) +{ + return endpoint_node + .child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + REPORTED_ATTRIBUTE) + .is_valid(); +} + +/** + * @brief Get node associated with user ID (desired or reported) + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If User ID does not exist with given state + * + * @return User ID Node + */ +attribute_store::attribute + get_user_unique_id_node(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id, + attribute_store_node_value_state_t state) +{ + attribute_store::attribute user_id_node + = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + state); + + if (!user_id_node.is_valid()) { + throw std::runtime_error( + (boost::format("User ID %1% not found (state : %2%).") % user_id % state) + .str()); + } + + return user_id_node; +} + +/** + * @brief Get credential type node associated with user ID + * + * @param user_id_node User ID node + * @param cred_type Credential type + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If Credential type for given user_id_node does not exist with given state + * + * @return Credential type node + */ +attribute_store::attribute + get_credential_type_node(attribute_store::attribute user_id_node, + user_credential_type_t cred_type, + attribute_store_node_value_state_t state) +{ + if (!user_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_type_node: User ID node is not valid."); + } + + attribute_store::attribute cred_type_node + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + cred_type, + state); + + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + (boost::format("Credential type %1% (state : %2%) not found for %3%.") + % cred_type % state % user_id_node.value_to_string()) + .str()); + } + + return cred_type_node; +} + +/** + * @brief Get credential slot node associated with credential type + * + * @param cred_type_node Credential type node + * @param cred_slot Credential slot + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If Credential slot for given cred_type_node does not exist with given state + * + * @return Credential slot node + */ +attribute_store::attribute + get_credential_slot_node(attribute_store::attribute cred_type_node, + user_credential_slot_t cred_slot, + attribute_store_node_value_state_t state) +{ + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + "get_credential_slot_node: Credential Type node is not valid."); + } + + attribute_store::attribute cred_slot_node + = cred_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), + cred_slot, + state); + + if (!cred_slot_node.is_valid()) { + throw std::runtime_error( + (boost::format( + "Credential type %1% (state : %2%) not found for %3% / %4%.") + % cred_slot % state % cred_type_node.value_to_string()) + .str()); + } + + return cred_slot_node; +} + /** * @brief Get credential node associated with credential_type and user_id. * + * @deprecated + * * @param endpoint_node Current endpoint node * @param user_id User ID * @param credential_type Credential type @@ -932,7 +1062,7 @@ sl_status_t node_to_uint8_vector(attribute_store_node_t node, // First get the length auto credential_data_length = attribute_store_get_node_value_size(node, value_state); - + // + 1 for the length data.resize(credential_data_length + 1); data[0] = credential_data_length; @@ -1133,115 +1263,6 @@ sl_status_t update_desired_values( namespace notification_handler { -namespace user -{ -// Indexes -// User Notification Report Frame -constexpr uint8_t INDEX_USER_MODIFIER_TYPE = 0; -constexpr uint8_t INDEX_USER_MODIFIER_NODE_ID = 1; -constexpr uint8_t INDEX_USER_UNIQUE_ID = 3; -constexpr uint8_t INDEX_USER_TYPE = 5; -constexpr uint8_t INDEX_USER_ACTIVE_STATE = 6; -constexpr uint8_t INDEX_USER_CREDENTIAL_RULE = 7; -constexpr uint8_t INDEX_USER_EXPIRING_TIMEOUT_MINUTES = 8; -constexpr uint8_t USER_NOTIFICATION_REPORT_FRAME_LENGTH - = INDEX_USER_EXPIRING_TIMEOUT_MINUTES + 2; - -// Constains the indexes mapped of the User Notification Report -const std::vector user_notification_report_data - = {{ATTRIBUTE(USER_MODIFIER_TYPE), INDEX_USER_MODIFIER_TYPE}, - {ATTRIBUTE(USER_MODIFIER_NODE_ID), INDEX_USER_MODIFIER_NODE_ID}, - {ATTRIBUTE(USER_TYPE), INDEX_USER_TYPE}, - {ATTRIBUTE(USER_ACTIVE_STATE), - INDEX_USER_ACTIVE_STATE, - USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK}, - {ATTRIBUTE(CREDENTIAL_RULE), INDEX_USER_CREDENTIAL_RULE}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - INDEX_USER_EXPIRING_TIMEOUT_MINUTES}}; - -// Contains all the user data attributes -const std::vector user_data_attribute_types - = {ATTRIBUTE(USER_MODIFIER_TYPE), - ATTRIBUTE(USER_MODIFIER_NODE_ID), - ATTRIBUTE(USER_TYPE), - ATTRIBUTE(USER_ACTIVE_STATE), - ATTRIBUTE(CREDENTIAL_RULE), - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - ATTRIBUTE(USER_NAME_ENCODING), - ATTRIBUTE(USER_NAME)}; - -user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) -{ - return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); -} - -user_credential_modifier_type_t - get_user_modifier_type(const uint8_t *event_parameters) -{ - return event_parameters[INDEX_USER_MODIFIER_TYPE]; -} -// Get user node reported in the notification parameters -attribute_store_node_t get_user_node(attribute_store_node_t endpoint_node, - const uint8_t *event_parameters, - attribute_store_node_value_state_t state) -{ - user_credential_user_unique_id_t user_id - = get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); - - attribute_store_node_t user_node - = (state == REPORTED_ATTRIBUTE) - ? get_reported_user_id_node(endpoint_node, user_id) - : get_desired_user_id_node(endpoint_node, user_id); - - if (user_node == ATTRIBUTE_STORE_INVALID_NODE) { - sl_log_debug(LOG_TAG, - "Can't find user %d present in Notification Parameters", - user_id); - } - return user_node; -} - -void update_user_reported_values(attribute_store_node_t user_id_node, - const uint8_t *event_parameters) -{ - sl_status_t set_status - = set_reported_attributes(user_id_node, - event_parameters, - user_notification_report_data); - - if (set_status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Error while setting reported attributes"); - } - - // Those are not present in the User Notification command, we assume they stay the same - // FIXME: https://github.com/Z-Wave-Alliance/AWG/issues/168 - auto user_name_encoding_node - = attribute_store_get_node_child_by_type(user_id_node, - ATTRIBUTE(USER_NAME_ENCODING), - 0); - attribute_store_set_reported_as_desired(user_name_encoding_node); - auto user_name_node - = attribute_store_get_node_child_by_type(user_id_node, - ATTRIBUTE(USER_NAME), - 0); - attribute_store_set_reported_as_desired(user_name_node); -}; - -bool is_report_size_conform(uint8_t event_parameters_length) -{ - if (event_parameters_length != USER_NOTIFICATION_REPORT_FRAME_LENGTH) { - sl_log_error( - LOG_TAG, - "Invalid User Notification Report size got %0xd, expected %0xd", - event_parameters_length, - USER_NOTIFICATION_REPORT_FRAME_LENGTH); - return false; - } - return true; -}; - -} // namespace user - namespace credential { // Indexes @@ -1451,128 +1472,6 @@ void on_notification_event(attribute_store_node_t endpoint_node, // Logic switch (event_code) { - // User unchanged - case 0x2A: { - sl_log_debug(LOG_TAG, "Notification : User Unchanged"); - if (!notification_handler::user::is_report_size_conform( - event_parameters_length)) { - return; - } - user_credential_user_unique_id_t user_id - = notification_handler::user::get_user_id(event_parameters); - - attribute_store_node_t user_id_node - = notification_handler::user::get_user_node(endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - if (!attribute_store_node_exists(user_id_node)) { - // Check desired value in case the Add operation didn't work - user_id_node - = notification_handler::user::get_user_node(endpoint_node, - event_parameters, - DESIRED_ATTRIBUTE); - - // If still not exists we return an error - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, "Didn't find user ID %d.", user_id); - return; - } - } - - // If user doesn't exists in the device we try to remove it also from our side - user_credential_modifier_type_t modifier_type - = notification_handler::user::get_user_modifier_type(event_parameters); - if (modifier_type == USER_REPORT_DNE) { - attribute_store_delete_node(user_id_node); - } else { - sl_log_info(LOG_TAG, "User Unchanged, clearing desired values."); - - for (auto &user_data_type: - notification_handler::user::user_data_attribute_types) { - attribute_store_undefine_desired( - attribute_store_get_node_child_by_type(user_id_node, - user_data_type, - 0)); - } - } - } break; - // User Added - case 0x27: { - sl_log_debug(LOG_TAG, "Notification : User Added"); - - if (!notification_handler::user::is_report_size_conform( - event_parameters_length)) { - return; - } - // User node - attribute_store_node_t user_id_node - = notification_handler::user::get_user_node(endpoint_node, - event_parameters, - DESIRED_ATTRIBUTE); - user_credential_user_unique_id_t user_id - = notification_handler::user::get_user_id(event_parameters); - - // Fallback if we didn't find the user in desired value, we check the reported ones - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "Didn't find user ID %d in 'add state' (desired value). " - "Can't add user.", - user_id); - return; - } else { - // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason - attribute_store_undefine_desired(user_id_node); - // If we found the user id, we mark it a reported now. - attribute_store_set_reported(user_id_node, &user_id, sizeof(user_id)); - } - - notification_handler::user::update_user_reported_values(user_id_node, - event_parameters); - - } break; - // User Modified - case 0x28: { - sl_log_debug(LOG_TAG, "Notification : User Modified"); - - if (!notification_handler::user::is_report_size_conform( - event_parameters_length)) { - return; - } - - attribute_store_node_t user_id_node - = notification_handler::user::get_user_node(endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - - if (!attribute_store_node_exists(user_id_node)) { - user_credential_user_unique_id_t user_id - = notification_handler::user::get_user_id(event_parameters); - sl_log_error(LOG_TAG, - "Didn't find user ID %d. Can't modify user.", - user_id); - return; - } - - notification_handler::user::update_user_reported_values(user_id_node, - event_parameters); - - } break; - // User Deleted - case 0x29: { - sl_log_debug(LOG_TAG, "Notification : User Deleted"); - - if (!notification_handler::user::is_report_size_conform( - event_parameters_length)) { - return; - } - - // Get user node so we can remove it - attribute_store_node_t deleted_user_id_node - = notification_handler::user::get_user_node(endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - attribute_store_delete_node(deleted_user_id_node); - } break; // Credential Added case 0x2B: { sl_log_debug(LOG_TAG, "Notification : Credential Added"); @@ -3396,9 +3295,28 @@ static sl_status_t zwave_command_class_user_credential_user_get( return SL_STATUS_FAIL; } + // This special user ID will contains the unaffected credentials. + if (user_id == 0) { + sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); + user_unique_id_node.clear_desired(); + user_unique_id_node.set_reported(user_id); + } + return SL_STATUS_OK; } +// TODO : Update with values in ZW_cmdclass.h +enum class user_report_type_t : uint8_t { + USER_ADDED = 0x00, + USER_MODIFIED = 0x01, + USER_DELETED = 0x02, + USER_UNCHANGED = 0x03, + RESPONSE_TO_GET = 0x04, + USER_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, + USER_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, + NON_ZERO_EXPIRING_MINUTES_INVALID = 0x07 +}; + sl_status_t zwave_command_class_user_credential_user_handle_report( const zwave_controller_connection_info_t *connection_info, const uint8_t *frame_data, @@ -3419,7 +3337,7 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( return SL_STATUS_FAIL; } - //parser.read_byte(); // TODO : use User Report Type; + auto user_report_type = static_cast(parser.read_byte()); auto next_user_id = parser.read_sequential(2); @@ -3432,76 +3350,115 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( auto current_user_id = parser.read_sequential(2); - sl_log_debug(LOG_TAG, "User report for user %d", current_user_id); - - auto remove_node_0_if_exists = [&]() { - attribute_store_node_t node_0; - get_user_id_node(endpoint_node, 0, DESIRED_ATTRIBUTE, node_0); - return attribute_store_delete_node(node_0); - }; + sl_log_debug(LOG_TAG, + "User report for user %d. User report type %d", + current_user_id, + user_report_type); // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node if (current_user_id == 0) { - sl_log_info(LOG_TAG, - "User report with ID 0 received. This probably means that no " - "user is defined on the device."); - sl_log_debug(LOG_TAG, - "Attempt to delete User Node ID with value %d", - current_user_id); - sl_status_t deletion_status = remove_node_0_if_exists(); - sl_log_debug(LOG_TAG, "Deletion returned status : %d", deletion_status); - return SL_STATUS_OK; - } + if (user_report_type == user_report_type_t::RESPONSE_TO_GET) { + sl_log_info(LOG_TAG, "No users was found on the device."); + return SL_STATUS_OK; + } else if (user_report_type == user_report_type_t::USER_DELETED) { + sl_log_info(LOG_TAG, "Request to delete all users"); + + for (auto user_node: + endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + // Don't delete special user 0 + if (user_node.reported_exists() + && user_node.reported() == 0) { + continue; + } - // Find user id - auto current_user_id_node - = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - if (!current_user_id_node.is_valid()) { - sl_log_debug(LOG_TAG, - "Could not find user %d with reported value, trying desired", - current_user_id); - // If User node doesn't exists with given desired attribute - current_user_id_node = endpoint_node.child_by_type_and_value_desired( - ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - - if (!current_user_id_node.is_valid()) { - sl_log_debug( - LOG_TAG, - "Could not find user %d with desired value, using the User ID 0", - current_user_id); - current_user_id_node = endpoint_node.child_by_type_and_value_desired< - user_credential_user_unique_id_t>(ATTRIBUTE(USER_UNIQUE_ID), 0); + attribute_store_delete_node(user_node); + } + + return SL_STATUS_OK; + } else { + sl_log_error(LOG_TAG, + "User report with ID 0 received. This is an invalid User " + "Unique Identifier and MUST NOT be used by the node."); + return SL_STATUS_FAIL; } } - // Check node existence - if (!current_user_id_node.is_valid()) { - sl_log_error(LOG_TAG, - "Can't find user with ID %d in USER_REPORT", - current_user_id); - return SL_STATUS_NOT_SUPPORTED; - } + // Lambda function to remove user node in an invalid state + auto remove_current_user_node = [&]() { + get_user_unique_id_node(endpoint_node, current_user_id, DESIRED_ATTRIBUTE) + .delete_node(); + }; - if (user_modifier_type == USER_REPORT_DNE) { - sl_log_debug( - LOG_TAG, - "User %d does not exist anymore, removing from attribute store.", - current_user_id); - attribute_store_delete_node(current_user_id_node); + // Current user id node that will be used later + // Each report type has a different behavior + attribute_store::attribute current_user_id_node; + switch (user_report_type) { + // Need to create new user node + case user_report_type_t::USER_ADDED: + current_user_id_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + // If this is the first user we get it might not exists yet so we create it. + // Otherwise we just update the reported value + case user_report_type_t::RESPONSE_TO_GET: + current_user_id_node + = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id, + DESIRED_ATTRIBUTE); + if (!current_user_id_node.is_valid()) { + current_user_id_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + } else { + current_user_id_node.set_reported(current_user_id); + current_user_id_node.clear_desired(); + } + break; + // We should have a record of given user ID + case user_report_type_t::USER_MODIFIED: + case user_report_type_t::USER_DELETED: + current_user_id_node = get_user_unique_id_node(endpoint_node, + current_user_id, + REPORTED_ATTRIBUTE); + break; + // Special/Errors cases + case user_report_type_t::USER_UNCHANGED: + sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); + return SL_STATUS_OK; + break; + case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: + sl_log_warning(LOG_TAG, + "User %d was not added since it already exists. Try to " + "modify it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::USER_MODIFY_REJECTED_LOCATION_EMPTY: + sl_log_warning(LOG_TAG, + "User %d was not modified since it doesn't exists. Try " + "to add it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: + sl_log_warning(LOG_TAG, + "User %d was not modified/added since the expiring timeout minutes is invalid.", + current_user_id); + return SL_STATUS_OK; + default: + sl_log_error(LOG_TAG, "Invalid value for user report type."); + return SL_STATUS_FAIL; + }; + + // Deleted special case + if (user_report_type == user_report_type_t::USER_DELETED) { + // TODO : move all credential from this user to user 0 + // Maybe it is done automatically by the credential report + sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); + current_user_id_node.delete_node(); return SL_STATUS_OK; } - // Everything is fine, set the reported value to the current user id node - current_user_id_node.set_reported(current_user_id); - current_user_id_node.clear_desired(); - - // Remove leftover of node 0 if it exists - // This is necessary if we are interviewing again the user as this node will be left undefined - // and causing a get loop. - remove_node_0_if_exists(); - // Set already parsed values current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) .set_reported(user_modifier_type); @@ -3527,12 +3484,21 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( // Get credentials trigger_get_credential(current_user_id_node, 0, 0); - if (next_user_id != 0) { - sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); - trigger_get_user(endpoint_node, next_user_id); + if (next_user_id != 0 + && user_report_type == user_report_type_t::RESPONSE_TO_GET) { + if (!user_exists(endpoint_node, next_user_id)) { + sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(next_user_id); + } else { + sl_log_error(LOG_TAG, + "User %d already exists. Not discovering more users.", + next_user_id); + } } else { sl_log_debug(LOG_TAG, "No more users to discover"); } + } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while parsing User Report frame : %s", diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 3c0cf47f8..d913965fe 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1486,6 +1486,7 @@ void test_user_credential_user_get_not_found() } std::vector helper_create_user_report_frame( + uint8_t user_report_type, user_credential_user_unique_id_t next_user_id, user_credential_modifier_type_t user_modifier_type, user_credential_modifier_node_id_t user_modifier_node_id, @@ -1500,6 +1501,8 @@ std::vector helper_create_user_report_frame( std::vector report_frame = {COMMAND_CLASS_USER_CREDENTIAL, USER_REPORT}; + report_frame.push_back(user_report_type); + auto exploded_next_user_id = explode_uint16(next_user_id); report_frame.push_back(exploded_next_user_id.msb); report_frame.push_back(exploded_next_user_id.lsb); @@ -1683,7 +1686,9 @@ void test_user_credential_user_report_happy_case() "Credential Slot should be at 0 and should exists"); }; // end test_user_values lambda - auto report_frame = helper_create_user_report_frame(next_user_id, + // Todo : update this value with define from zw_cmdclass.h when updated + auto report_frame = helper_create_user_report_frame(0x04, + next_user_id, user_modifier_type, user_modifier_node_id, user_id, @@ -1717,31 +1722,30 @@ void test_user_credential_user_report_happy_case() handler.control_handler(&info, report_frame.data(), report_frame.size()), "User Report should have returned SL_STATUS_OK"); // Test values + // For the first + first_user_id_node + = attribute_store_get_node_child_by_type(endpoint_id_node, + ATTRIBUTE(USER_UNIQUE_ID), + 1); test_user_values(first_user_id_node); // Test structure auto user_id_count = attribute_store_get_node_child_count_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID)); - TEST_ASSERT_EQUAL_MESSAGE(2, - user_id_count, - "User node count mismatch. Should be 2 : 1 for " - "the reported one and 1 for the next one"); + TEST_ASSERT_EQUAL_MESSAGE( + 3, + user_id_count, + "User node count mismatch. Should be 3 by now. One with special id 0, the " + "reported one and the new desired one"); + auto second_user_id_node = attribute_store_get_node_child_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID), - 1); + 2); printf("Second and last user creation\n"); - // Simulate a node with desired value of 0 to see if it is properly removed - // to prevent infinite loop - user_credential_user_unique_id_t id_zero = 0; - attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &id_zero, - sizeof(id_zero)); - // Check second & not defined user id user_credential_user_unique_id_t second_user_id; attribute_store_get_desired(second_user_id_node, @@ -1772,7 +1776,8 @@ void test_user_credential_user_report_happy_case() user_name_encoding = 1; user_name = "NoDoUzE4YoU"; - report_frame = helper_create_user_report_frame(next_user_id, + report_frame = helper_create_user_report_frame(0x04, + next_user_id, user_modifier_type, user_modifier_node_id, user_id, @@ -1794,9 +1799,9 @@ void test_user_credential_user_report_happy_case() user_id_count = attribute_store_get_node_child_count_by_type(endpoint_id_node, ATTRIBUTE(USER_UNIQUE_ID)); - TEST_ASSERT_EQUAL_MESSAGE(2, + TEST_ASSERT_EQUAL_MESSAGE(3, user_id_count, - "User node count mismatch. Should only 2 users created."); + "User node count mismatch. Should only 2 users + 1 with id 0 created."); user_credential_user_unique_id_t reported_id; attribute_store_get_reported(first_user_id_node, @@ -1813,29 +1818,6 @@ void test_user_credential_user_report_happy_case() "Second user id mismatch"); } -void test_user_credential_user_report_user_not_found() -{ - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - auto report_frame - = helper_create_user_report_frame(0, 0, 0, 12, 0, 0, 0, 0, 0, "^^"); - - // Not found since we haven't created any user_unique_id - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_NOT_SUPPORTED, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "User Report should have returned SL_STATUS_NOT_SUPPORTED"); - - // Check that no user_unique_id node has been created - auto user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); - TEST_ASSERT_EQUAL_MESSAGE(0, - user_id_count, - "No user_unique_id node should be created"); -} void test_user_credential_user_report_user_with_id0() { @@ -1844,14 +1826,7 @@ void test_user_credential_user_report_user_with_id0() info.remote.endpoint_id = endpoint_id; info.local.is_multicast = false; auto report_frame - = helper_create_user_report_frame(0, 0, 0, 0, 0, 0, 0, 0, 0, "DOUZE"); - - // Create user id with reported ID of 0 to simulate user get of id 0 - user_credential_user_unique_id_t user_id = 0; - attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + = helper_create_user_report_frame(0x04, 0, 0, 0, 0, 0, 0, 0, 0, 0, "DOUZE"); // Not found since we haven't created any user_unique_id TEST_ASSERT_EQUAL_MESSAGE( @@ -1891,7 +1866,8 @@ void test_user_credential_user_report_user_deleted() ATTRIBUTE(USER_UNIQUE_ID)); TEST_ASSERT_EQUAL_MESSAGE(1, user_id_count, "Should have one user by now"); - auto report_frame = helper_create_user_report_frame(user_id, + auto report_frame = helper_create_user_report_frame(0x04, + user_id, USER_REPORT_DNE, 0, 0, @@ -1916,6 +1892,11 @@ void test_user_credential_user_report_user_deleted() "Should not have any user by now"); } + +void test_user_credential_user_added_happy_case() { + +} + //////////////////////////////////////////////////////////////////////////// // Credential Set/Get/Report //////////////////////////////////////////////////////////////////////////// @@ -2804,17 +2785,12 @@ void test_user_credential_add_credential_invalid_slot() "supported slot)"); } -void test_user_credential_user_notification_add_modify_delete_happy_case() +void test_user_credential_user_add_modify_delete_happy_case() { - // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; // Those functions are exposed and checks user values, so we need to setup the capabilities uint16_t number_of_users = 12; @@ -2870,21 +2846,25 @@ void test_user_credential_user_notification_add_modify_delete_happy_case() user_credential_modifier_type_t user_modifier_type = 2; user_credential_modifier_node_id_t user_modifier_node_id = 1212; - auto user_notification_report_frame - = helper_create_user_notification_report(user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout); + auto user_report_frame + = helper_create_user_report_frame(0x00, // user added + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); // Endpoint send User Add notification - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x27, // User added - user_notification_report_frame.data(), - user_notification_report_frame.size()); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to create user"); // Check values auto test_attribute_store_values = [&]() { @@ -2912,39 +2892,46 @@ void test_user_credential_user_notification_add_modify_delete_happy_case() user_name_encoding = 2; user_name = "JACKIE CAMION TURBO PLUS"; - status = zwave_command_class_user_credential_modify_user(endpoint_id_node, - user_id, - user_type, - credential_rule, - user_active_state, - expiring_timeout, - user_name_encoding, - user_name.c_str()); + user_report_frame = helper_create_user_report_frame(0x01, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); + // Endpoint send User Add notification TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - status, - "User modify should have returned SL_STATUS_OK"); + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to modify user"); // Create notification report frame user_modifier_type = 5; user_modifier_node_id = 12122; - user_notification_report_frame - = helper_create_user_notification_report(user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout); - - // Endpoint send User Modify notification - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x28, // User modified - user_notification_report_frame.data(), - user_notification_report_frame.size()); + user_report_frame = helper_create_user_report_frame(0x01, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to modify user"); // Check values test_attribute_store_values(); @@ -2955,25 +2942,22 @@ void test_user_credential_user_notification_add_modify_delete_happy_case() status, "User delete should have returned SL_STATUS_OK"); - // Should be the same as existing user - user_notification_report_frame - = helper_create_user_notification_report(user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout); - - // Endpoint send User Modify notification - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x29, // User deleted - user_notification_report_frame.data(), - user_notification_report_frame.size()); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_node), - "User node should be deleted"); + user_report_frame = helper_create_user_report_frame(0x02, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to delete user"); } void test_user_credential_credential_notification_add_modify_delete_happy_case() @@ -3614,6 +3598,11 @@ void test_user_credential_credential_modify_capabilites_failure_cases() void test_user_credential_user_set_error_report_user_add_happy_case() { + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + user_credential_user_unique_id_t user_id = 12; // Simulate invalid user @@ -3628,8 +3617,9 @@ void test_user_credential_user_set_error_report_user_add_happy_case() &user_id, sizeof(user_id)); - helper_simulate_user_set_error_report( - USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED, + auto user_report_frame = helper_create_user_report_frame( + 0x05, // USER_ADD_REJECTED_LOCATION_OCCUPIED + 0, // Next user id 1, 2, user_id, @@ -3639,6 +3629,12 @@ void test_user_credential_user_set_error_report_user_add_happy_case() 0, 0, "TAJINE AUX EPICES"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to handle USER_ADD_REJECTED_LOCATION_OCCUPIED"); TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), "Invalid User node should not exist"); @@ -3648,6 +3644,11 @@ void test_user_credential_user_set_error_report_user_add_happy_case() void test_user_credential_user_set_error_report_user_modify_happy_case() { + zwave_controller_connection_info_t info = {}; + info.remote.node_id = node_id; + info.remote.endpoint_id = endpoint_id; + info.local.is_multicast = false; + user_credential_user_unique_id_t user_id = 12; // Simulate invalid user (desired) @@ -3657,8 +3658,9 @@ void test_user_credential_user_set_error_report_user_modify_happy_case() &user_id, sizeof(user_id)); - helper_simulate_user_set_error_report( - USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY, + auto user_report_frame = helper_create_user_report_frame( + 0x06, // USER_MODIFY_REJECTED_LOCATION_EMPTY + 0, // Next user id 1, 2, user_id, @@ -3668,27 +3670,12 @@ void test_user_credential_user_set_error_report_user_modify_happy_case() 0, 0, "SAUCISSE FUMEE"); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), - "Invalid User node should not exist"); - - // Simulate invalid user (reported) - invalid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - helper_simulate_user_set_error_report( - USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY, - 1, - 2, - user_id, - 1, - 0, - 1, - 0, - 0, - "TURBO BARBEUC"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + handler.control_handler(&info, + user_report_frame.data(), + user_report_frame.size()), + "Should have managed to handle USER_MODIFY_REJECTED_LOCATION_EMPTY"); TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), "Invalid User node should not exist"); @@ -5343,7 +5330,8 @@ void test_get_user_checksum_with_credentials_happy_case() user_id_node, {{user_id_node, DESIRED_ATTRIBUTE}}); - auto user_report_frame = helper_create_user_report_frame(0, + auto user_report_frame = helper_create_user_report_frame(0x04, + 0, 0x02, // Z-Wave 0, user_id, @@ -5450,7 +5438,8 @@ void test_get_user_checksum_without_credentials_happy_case() user_id_node, {{user_id_node, DESIRED_ATTRIBUTE}}); - auto user_report_frame = helper_create_user_report_frame(0, + auto user_report_frame = helper_create_user_report_frame(0x04, + 0, 0x02, // Z-Wave 0, user_id, @@ -5511,7 +5500,8 @@ void test_get_user_checksum_without_credentials_mismatch_checksum() user_id_node, {{user_id_node, DESIRED_ATTRIBUTE}}); - auto user_report_frame = helper_create_user_report_frame(0, + auto user_report_frame = helper_create_user_report_frame(0x04, + 0, 0x02, // Z-Wave 0, user_id, From 5a118c8a91df5a1892ea64a118dea6b97186f864 Mon Sep 17 00:00:00 2001 From: Philippe Coval Date: Mon, 20 Jan 2025 16:39:28 +0100 Subject: [PATCH 26/60] UIC-3222: Refactor tests with new API [Philippe Coval] Adjusted Conflicts in: applications/zpc/components/zwave_command_classes/test/CMakeLists.txt --- .../zwave_command_classes/test/CMakeLists.txt | 43 +- ...ave_command_class_user_credential_test.cpp | 3668 ++++++----------- 2 files changed, 1198 insertions(+), 2513 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt index 8fd7005d5..e79a13e0d 100644 --- a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt @@ -150,26 +150,6 @@ target_add_unittest( uic_dotdot_mqtt_mock ) -# User credential test -target_add_unittest( - zwave_command_classes - NAME - zwave_command_class_user_credential_test - SOURCES - zwave_command_class_user_credential_test.cpp - # Allow to use notification mock - EXCLUDE - zwave_command_class_notification.cpp - DEPENDS - zpc_attribute_store_test_helper - zwave_controller - zwave_command_handler_mock - uic_attribute_resolver_mock - zpc_attribute_resolver_mock - uic_dotdot_mqtt_mock - zwave_network_management_mock - zwave_command_class_notification_mock) - # Wake Up Command Class target_add_unittest( zwave_command_classes @@ -877,7 +857,6 @@ target_add_unittest( zpc_attribute_resolver_mock uic_dotdot_mqtt_mock) - # CRC16 test target_add_unittest( zwave_command_classes @@ -923,3 +902,25 @@ target_add_unittest( zwave_tx_mock zwave_tx_scheme_selector_mock ) + +# User credential test +target_add_unittest( + zwave_command_classes + NAME + zwave_command_class_user_credential_test + SOURCES + zwave_command_class_user_credential_test.cpp + # Allow to use notification mock + EXCLUDE + zwave_command_class_notification.cpp + DEPENDS + zwave_command_class_test_helpers + zpc_attribute_store_test_helper + zwave_controller + zwave_command_handler_mock + uic_attribute_resolver_mock + zpc_attribute_resolver_mock + uic_dotdot_mqtt_mock + zwave_network_management_mock + zwave_command_class_notification_mock) + diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index d913965fe..65b5a1a31 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -14,6 +14,11 @@ #include "workaround_for_test.hpp" #include "attribute.hpp" +// Test helpers +#include "zwave_command_class_test_helper.hpp" + +using namespace zwave_command_class_test_helper; + extern "C" { #include "zwave_command_class_user_credential.h" @@ -32,16 +37,12 @@ extern "C" { #include "attribute_store_type_registration.h" #include "zpc_attribute_store_type_registration.h" - // Interface includes #include "attribute_store_defined_attribute_types.h" #include "ZW_classcmd.h" #include "zwave_utils.h" #include "zwave_controller_types.h" -// Test helpers -#include "zpc_attribute_store_test_helper.h" - // Mock includes #include "attribute_resolver_mock.h" #include "zpc_attribute_resolver_mock.h" @@ -55,14 +56,7 @@ extern "C" { #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type -static zwave_command_handler_t handler = {}; - -// This assumes that XXX_GET and XXX_SET id are > 0 -struct bound_functions { - uint8_t get_func_id; - uint8_t set_func_id; -}; -static std::map attributes_binding = { +const resolver_function_map attributes_binding = { {ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, @@ -78,126 +72,68 @@ static std::map attributes_binding = { {ATTRIBUTE(CREDENTIAL_CHECKSUM), {CREDENTIAL_CHECKSUM_GET, 0}}, }; -// Filed with resolver function for given ID in attribute_resolver_register_rule_stub based on -// attributes_binding map. -// -// e.g : resolver_functions[USER_CAPABILITIES_GET] = user_capabilities_get_func() -static std::map resolver_functions; +// Tested command class handler +const zwave_struct_handler_args command_class_handler + = {.command_class_id = COMMAND_CLASS_USER_CREDENTIAL, + .supported_version = USER_CREDENTIAL_VERSION, + .scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS}; // Notification callback static notification_event_callback_t notification_callback; -// Buffer for frame -static uint8_t received_frame[255] = {}; -static uint16_t received_frame_size = 0; - -const uint8_t MAX_CHAR_SIZE = 64; -///////////////////////////////////////////////////// -// C++ HELPERS -///////////////////////////////////////////////////// -} // Extern C - -#ifdef __cplusplus -template void helper_test_attribute_store_values( - std::map attribute_map_values, - attribute_store_node_t parent = ATTRIBUTE_STORE_INVALID_NODE) -{ - if (parent == ATTRIBUTE_STORE_INVALID_NODE) { - parent = endpoint_id_node; - } - - for (auto &attr: attribute_map_values) { - T value; - sl_status_t status = attribute_store_get_child_reported(parent, - attr.first, - &value, - sizeof(value)); - - std::string message - = "Can't get reported value of " - + std::string(attribute_store_get_type_name(attr.first)); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); - - message = "Mismatch value for attribute : " - + std::string(attribute_store_get_type_name(attr.first)); - TEST_ASSERT_EQUAL_MESSAGE(attr.second, value, message.c_str()); - } -} -#endif - -extern "C" { ///////////////////////////////////////////////////// // HELPERS ///////////////////////////////////////////////////// -struct uint16_exploded { - uint8_t msb; // Most Significant Bit - uint8_t lsb; // Less Significant Bit -}; -uint16_exploded explode_uint16(uint16_t value) -{ - uint8_t msb = (value & 0xFF00) >> 8; - uint8_t lsb = (value & 0x00FF); - return uint16_exploded {msb, lsb}; -} - struct credential_structure_nodes { - attribute_store_node_t user_id_node; - attribute_store_node_t credential_type_node; - attribute_store_node_t credential_slot_node; + attribute_store::attribute user_id_node; + attribute_store::attribute credential_type_node; + attribute_store::attribute credential_slot_node; + + void print() + { + printf("%s / %s / %s\n", + user_id_node.name_and_id().c_str(), + credential_type_node.name_and_id().c_str(), + credential_slot_node.name_and_id().c_str()); + }; }; -void helper_simulate_user_set_error_report( - uint8_t user_set_error_type, - user_credential_modifier_type_t user_modifier_type, - user_credential_modifier_node_id_t user_modifier_node_id, +/** + * @brief Create credential structure and return associated nodes + * + * @param user_id + * @param credential_type + * @param credential_slot + * @param value_state If DESIRED_ATTRIBUTE : credential_type/credential_slot will have their desired value setup, reported otherwise + * @return credential_structure_nodes + */ +credential_structure_nodes helper_create_credential_structure( user_credential_user_unique_id_t user_id, - user_credential_user_type_t user_type, - user_credential_user_active_state_t user_active_state, - user_credential_supported_credential_rules_t credential_rule, - user_credential_expiring_timeout_minutes_t expiring_timeout_minutes, - user_credential_user_name_encoding_t user_name_encoding, - std::string user_name) + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + attribute_store_node_value_state_t value_state = DESIRED_ATTRIBUTE) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, USER_SET_ERROR_REPORT}; - - report_frame.push_back(user_set_error_type); - report_frame.push_back(user_modifier_type); - - auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); - report_frame.push_back(exploded_user_modifier_node_id.msb); - report_frame.push_back(exploded_user_modifier_node_id.lsb); - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); + credential_structure_nodes nodes; - report_frame.push_back(user_type); - report_frame.push_back(user_active_state); - report_frame.push_back(credential_rule); + nodes.user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - auto exploded_expiring_timeout_minutes - = explode_uint16(expiring_timeout_minutes); - report_frame.push_back(exploded_expiring_timeout_minutes.msb); - report_frame.push_back(exploded_expiring_timeout_minutes.lsb); + nodes.credential_type_node + = nodes.user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); - report_frame.push_back((uint8_t)user_name.size()); - for (const char &c: user_name) { - report_frame.push_back(c); - } + nodes.credential_slot_node + = nodes.credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + value_state); - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + return nodes; } +//////////////////////////////////////////////////// +// Report helpers +//////////////////////////////////////////////////// + void helper_simulate_credential_set_error_report( uint8_t credential_set_error_type, user_credential_user_unique_id_t user_id, @@ -208,43 +144,18 @@ void helper_simulate_credential_set_error_report( user_credential_modifier_type_t modifier_type, user_credential_modifier_node_id_t modifier_node_id) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_SET_ERROR_REPORT}; - - report_frame.push_back(credential_set_error_type); - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(credential_type); - - auto exploded_credential_slot = explode_uint16(credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); - - report_frame.push_back(crb << 7); - - report_frame.push_back((uint8_t)credential_data.size()); - for (const char &c: credential_data) { - report_frame.push_back(c); - } - - report_frame.push_back(modifier_type); - - auto exploded_modifier_node_id = explode_uint16(modifier_node_id); - report_frame.push_back(exploded_modifier_node_id.msb); - report_frame.push_back(exploded_modifier_node_id.lsb); - - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + zwave_frame report_frame; + + report_frame.add(credential_set_error_type); + report_frame.add(user_id); + report_frame.add(credential_type); + report_frame.add(credential_slot); + report_frame.add(crb); + report_frame.add(credential_data); + report_frame.add(modifier_type); + report_frame.add(modifier_node_id); + + helper_test_report_frame(CREDENTIAL_SET_ERROR_REPORT, report_frame); } void helper_simulate_user_capabilites_report( @@ -257,36 +168,20 @@ void helper_simulate_user_capabilites_report( uint8_t supported_user_types_bitmask_length, user_credential_supported_user_type_bitmask_t supported_user_types_bitmask) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame = { - COMMAND_CLASS_USER_CREDENTIAL, - USER_CAPABILITIES_REPORT, - (uint8_t)((number_of_users & 0xFF00) >> 8), // MSB - (uint8_t)(number_of_users & 0x00FF), // LSB - cred_rule_bitmask, - username_max_length, - (uint8_t)((support_user_schedule << 7) | (support_all_users_checksum << 6) - | (support_user_checksum << 5)), - supported_user_types_bitmask_length}; + zwave_frame report_frame; + + report_frame.add(number_of_users); + report_frame.add(cred_rule_bitmask); + report_frame.add(username_max_length); + uint8_t support_byte = (support_user_schedule << 7) + | (support_all_users_checksum << 6) + | (support_user_checksum << 5); + report_frame.add(support_byte); + report_frame.add_bitmask(supported_user_types_bitmask_length, + supported_user_types_bitmask); // Add bitmask value - for (uint8_t i = 0; i < supported_user_types_bitmask_length; i++) { - uint8_t offset = i; - uint8_t shift = 8 * offset; - uint32_t bitmask = 0xFF << shift; - - uint8_t value_8bit = (supported_user_types_bitmask & bitmask) >> shift; - report_frame.push_back(value_8bit); - } - - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_test_report_frame(USER_CAPABILITIES_REPORT, report_frame); } void helper_simulate_credential_capabilites_report( @@ -311,53 +206,34 @@ void helper_simulate_credential_capabilites_report( "should be the same."); } - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, - CREDENTIAL_CAPABILITIES_REPORT, - (uint8_t)(credential_checksum_support << 7), - (uint8_t)credential_type.size()}; - - auto push_uint16 = [&](std::vector vector) { - for (auto &v: vector) { - report_frame.push_back((uint8_t)((v & 0xFF00) >> 8)); - report_frame.push_back((uint8_t)(v & 0x00FF)); - } - }; + zwave_frame report_frame; + + report_frame.add(static_cast(credential_checksum_support << 7)); + report_frame.add(static_cast(credential_type.size())); for (auto &c: credential_type) { - report_frame.push_back(c); + report_frame.add(c); } - for (auto &cl: cl_support) { - report_frame.push_back((uint8_t)(cl << 7)); + report_frame.add(static_cast(cl << 7)); + } + for (auto &c: supported_credential_slots) { + report_frame.add(c); } - - push_uint16(supported_credential_slots); - for (auto &c: min_length) { - report_frame.push_back(c); + report_frame.add(c); } for (auto &c: max_length) { - report_frame.push_back(c); + report_frame.add(c); } - for (auto &c: cl_timeout) { - report_frame.push_back(c); + report_frame.add(c); } - for (auto &c: cl_steps) { - report_frame.push_back(c); + report_frame.add(c); } - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_test_report_frame(CREDENTIAL_CAPABILITIES_REPORT, report_frame); }; void helper_simulate_user_checksum_report( @@ -365,25 +241,11 @@ void helper_simulate_user_checksum_report( user_credential_checksum_t expected_checksum, sl_status_t expected_status = SL_STATUS_OK) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector checksum_frame - = {COMMAND_CLASS_USER_CREDENTIAL, USER_CHECKSUM_REPORT}; - auto exploded_user_id = explode_uint16(user_id); - checksum_frame.push_back(exploded_user_id.msb); - checksum_frame.push_back(exploded_user_id.lsb); - auto exploded_expected_checksum = explode_uint16(expected_checksum); - checksum_frame.push_back(exploded_expected_checksum.msb); - checksum_frame.push_back(exploded_expected_checksum.lsb); + zwave_frame report_frame; + report_frame.add(user_id); + report_frame.add(expected_checksum); - // Do the report - TEST_ASSERT_EQUAL(expected_status, - handler.control_handler(&info, - checksum_frame.data(), - checksum_frame.size())); + helper_test_report_frame(USER_CHECKSUM_REPORT, report_frame, expected_status); } void helper_simulate_credential_checksum_report( @@ -391,61 +253,34 @@ void helper_simulate_credential_checksum_report( user_credential_checksum_t expected_checksum, sl_status_t expected_status = SL_STATUS_OK) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector checksum_frame - = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_CHECKSUM_REPORT}; - checksum_frame.push_back(credential_type); - auto exploded_expected_checksum = explode_uint16(expected_checksum); - checksum_frame.push_back(exploded_expected_checksum.msb); - checksum_frame.push_back(exploded_expected_checksum.lsb); + zwave_frame report_frame; + report_frame.add(credential_type); + report_frame.add(expected_checksum); - // Do the report - TEST_ASSERT_EQUAL(expected_status, - handler.control_handler(&info, - checksum_frame.data(), - checksum_frame.size())); + helper_test_report_frame(CREDENTIAL_CHECKSUM_REPORT, + report_frame, + expected_status); } -void helper_create_learn_status_report_frame( +void helper_simulate_learn_status_report_frame( uint8_t credential_learn_status, user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot, uint8_t learn_steps_remaining) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_LEARN_REPORT}; - - report_frame.push_back(credential_learn_status); + zwave_frame report_frame; - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); + report_frame.add(credential_learn_status); + report_frame.add(user_id); + report_frame.add(credential_type); + report_frame.add(credential_slot); + report_frame.add(learn_steps_remaining); - report_frame.push_back(credential_type); - - auto exploded_credential_slot = explode_uint16(credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); - - report_frame.push_back(learn_steps_remaining); - - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_test_report_frame(CREDENTIAL_LEARN_REPORT, report_frame); } -void helper_association_report_frame( +void helper_simulate_association_report_frame( user_credential_user_unique_id_t source_user_id, user_credential_type_t source_credential_type, user_credential_slot_t source_credential_slot, @@ -453,413 +288,134 @@ void helper_association_report_frame( user_credential_slot_t destination_credential_slot, uint8_t credential_association_status) { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, USER_CREDENTIAL_ASSOCIATION_REPORT}; - - auto exploded_user_id = explode_uint16(source_user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(source_credential_type); + zwave_frame report_frame; - auto exploded_credential_slot = explode_uint16(source_credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); + report_frame.add(source_user_id); + report_frame.add(source_credential_type); + report_frame.add(source_credential_slot); + report_frame.add(destination_user_id); + report_frame.add(destination_credential_slot); + report_frame.add(credential_association_status); - exploded_user_id = explode_uint16(destination_user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - exploded_credential_slot = explode_uint16(destination_credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); - - report_frame.push_back(credential_association_status); - - // Do the report - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + helper_test_report_frame(USER_CREDENTIAL_ASSOCIATION_REPORT, report_frame); } -/** - * @brief Create credential structure and return associated nodes - * - * @param user_id - * @param credential_type - * @param credential_slot - * @param value_state If DESIRED_ATTRIBUTE : credential_type/credential_slot will have their desired value setup, reported otherwise - * @return credential_structure_nodes - */ -credential_structure_nodes helper_create_credential_structure( - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - attribute_store_node_value_state_t value_state = DESIRED_ATTRIBUTE) -{ - credential_structure_nodes nodes; - nodes.user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - // It should be always reported - nodes.credential_type_node - = attribute_store_emplace(nodes.user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - - if (value_state == DESIRED_ATTRIBUTE) { - nodes.credential_slot_node - = attribute_store_emplace_desired(nodes.credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - } else { - nodes.credential_slot_node - = attribute_store_emplace(nodes.credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - } - - return nodes; -} - -void helper_test_get_no_args_happy_case(uint8_t get_command_id) -{ - auto &get_func = resolver_functions[get_command_id]; - - // Ask for a Get Command, should always be the same - TEST_ASSERT_NOT_NULL_MESSAGE( - get_func, - "Couldn't find get function in resolver_functions."); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - get_func(0, received_frame, &received_frame_size), - "Get function should have returned OK"); - - const uint8_t expected_frame[] - = {COMMAND_CLASS_USER_CREDENTIAL, get_command_id}; - TEST_ASSERT_EQUAL_MESSAGE(sizeof(expected_frame), - received_frame_size, - "Get frame size is incorrect"); - TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_frame, - received_frame, - received_frame_size, - "Get frame contents mismatch"); -} - -/** - * @brief Test given SET or GET function with args - * - * > Can also test if SET or GET command return SL_STATUS_NOT_SUPPORTED if node == INVALID_STORAGE_TYPE - * - * @param command_id Command that should be in resolver_functions - * @param base_node Base node on which the GET function will be called. If INVALID_STORAGE_TYPE expect the SET or GET function to return SL_STATUS_NOT_SUPPORTED and return. - * @param nodes Node data that will be used to check and construct the SET or GET frame (order matter since the first one will be the first argument, etc..) - * @param extra_bytes Extra bytes that will be added to the frame - */ -void helper_test_set_get_with_args( - uint8_t command_id, - attribute_store_node_t base_node, - std::vector< - std::pair> nodes - = {}, - std::vector extra_bytes = {}) -{ - auto &command_func = resolver_functions[command_id]; - - // Ask for a Get Command, should always be the same - TEST_ASSERT_NOT_NULL_MESSAGE( - command_func, - "Couldn't find command function in resolver_functions."); - - if (base_node == ATTRIBUTE_STORE_INVALID_NODE) { - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_NOT_SUPPORTED, - command_func(base_node, received_frame, &received_frame_size), - "Command function should have returned SL_STATUS_NOT_SUPPORTED since no " - "node " - "was provided"); - return; - } - - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - command_func(base_node, received_frame, &received_frame_size), - "Command function should have returned SL_STATUS_OK"); - - std::vector expected_frame - = {COMMAND_CLASS_USER_CREDENTIAL, command_id}; - - for (auto &node_data: nodes) { - auto node = node_data.first; - auto node_value_state = node_data.second; - - auto node_type = attribute_store_get_node_type(node); - auto node_storage_type = attribute_store_get_storage_type(node_type); - - sl_status_t status; - switch (node_storage_type) { - case U8_STORAGE_TYPE: { - uint8_t uint8_value; - status = attribute_store_read_value(node, - node_value_state, - &uint8_value, - sizeof(uint8_value)); - expected_frame.push_back(uint8_value); - } break; - case U16_STORAGE_TYPE: { - uint16_t uint16_value; - status = attribute_store_read_value(node, - node_value_state, - &uint16_value, - sizeof(uint16_value)); - auto exploded_uint16 = explode_uint16(uint16_value); - expected_frame.push_back(exploded_uint16.msb); - expected_frame.push_back(exploded_uint16.lsb); - } break; - // Variable length field - case BYTE_ARRAY_STORAGE_TYPE: { - uint8_t data_length - = attribute_store_get_node_value_size(node, node_value_state); - - std::vector data; - data.resize(data_length); - status = attribute_store_read_value(node, - node_value_state, - data.data(), - data_length); - - expected_frame.push_back(data_length); - for (uint8_t i = 0; i < data_length; i++) { - expected_frame.push_back(data[i]); - } - - } break; - case C_STRING_STORAGE_TYPE: { - char reported_c_str[MAX_CHAR_SIZE]; - - status = attribute_store_get_reported_string(node, - reported_c_str, - MAX_CHAR_SIZE); - std::string reported_cpp_str = reported_c_str; - if (reported_cpp_str.empty()) { - TEST_FAIL_MESSAGE("Can't get string value"); - } - - expected_frame.push_back(reported_cpp_str.length()); - for (const char &c: reported_cpp_str) { - expected_frame.push_back(c); - } - - } break; - default: - TEST_FAIL_MESSAGE( - "Unkown storage type in helper_test_set_get_with_args_happy_case"); - } - - std::string message - = "Should be able to get value of " - + std::string(attribute_store_type_get_node_type_name(node)); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); - } - - for (auto &byte: extra_bytes) { - expected_frame.push_back(byte); - } - - TEST_ASSERT_EQUAL_MESSAGE(expected_frame.size(), - received_frame_size, - "Command frame size is incorrect"); - TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_frame.data(), - received_frame, - received_frame_size, - "Command frame contents mismatch"); -} - -void helper_test_string_value( - std::map attribute_map_values, - attribute_store_node_t parent = ATTRIBUTE_STORE_INVALID_NODE) -{ - if (parent == ATTRIBUTE_STORE_INVALID_NODE) { - parent = endpoint_id_node; - } - - for (auto &attr: attribute_map_values) { - char reported_c_str[MAX_CHAR_SIZE]; - auto str_node = attribute_store_get_first_child_by_type(parent, attr.first); - sl_status_t status = attribute_store_get_reported_string(str_node, - reported_c_str, - MAX_CHAR_SIZE); - - std::string message - = "Can't get string reported value of " - + std::string(attribute_store_get_type_name(attr.first)); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, message.c_str()); - - message = "Mismatch value for attribute : " - + std::string(attribute_store_get_type_name(attr.first)); - TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(attr.second.c_str(), - reported_c_str, - attr.second.size() + 1, - message.c_str()); - } -} void helper_test_credential_learn_structure( - attribute_store_node_t user_id_node, - attribute_store_node_t credential_type_node, - attribute_store_node_t credential_slot_node, + attribute_store::attribute user_id_node, + attribute_store::attribute credential_type_node, + attribute_store::attribute credential_slot_node, user_credential_learn_timeout_t expected_cl_timeout, user_credential_operation_type_t expected_operation_type) { - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + TEST_ASSERT_TRUE_MESSAGE(user_id_node.is_valid(), "Credential type node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + TEST_ASSERT_TRUE_MESSAGE(credential_type_node.is_valid(), "Credential type node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + TEST_ASSERT_TRUE_MESSAGE(credential_slot_node.is_valid(), "Credential type slot should exist"); - uint8_t current_cl_timeout = 0; - auto cred_learn_timeout_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)); - attribute_store_get_reported(cred_learn_timeout_node, - ¤t_cl_timeout, - sizeof(current_cl_timeout)); - - TEST_ASSERT_EQUAL_MESSAGE(expected_cl_timeout, - current_cl_timeout, - "Timeout value mismatch."); - - user_credential_operation_type_t operation_type = 6; - auto operation_type_node = attribute_store_get_node_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - 0); - attribute_store_get_desired(operation_type_node, - &operation_type, - sizeof(operation_type)); - - TEST_ASSERT_EQUAL_MESSAGE(expected_operation_type, - operation_type, - "Operation type should be learn add"); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), + expected_cl_timeout, + credential_slot_node); + + auto operation_type_node + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + expected_operation_type, + credential_slot_node, + DESIRED_ATTRIBUTE); auto credential_type_state = expected_operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD ? DESIRED_ATTRIBUTE : REPORTED_ATTRIBUTE; - helper_test_set_get_with_args( - CREDENTIAL_LEARN_START, - operation_type_node, - {{user_id_node, REPORTED_ATTRIBUTE}, - {credential_type_node, credential_type_state}, - {credential_slot_node, REPORTED_ATTRIBUTE}, - {operation_type_node, DESIRED_ATTRIBUTE}, - {cred_learn_timeout_node, REPORTED_ATTRIBUTE}}); - - user_credential_user_unique_id_t user_id; - user_credential_type_t credential_type; - user_credential_slot_t credential_slot; - - attribute_store_get_reported(user_id_node, &user_id, sizeof(user_id)); - attribute_store_read_value(credential_type_node, - credential_type_state, - &credential_type, - sizeof(credential_type)); - attribute_store_get_reported(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); + user_credential_user_unique_id_t user_id + = user_id_node.reported(); + user_credential_type_t credential_type + = credential_type_node.get(credential_type_state); + user_credential_slot_t credential_slot + = credential_slot_node.reported(); - uint8_t step_remaining = 2; - user_credential_learn_status_t learn_status = CREDENTIAL_LEARN_REPORT_SUCCESS; - helper_create_learn_status_report_frame(learn_status, - user_id, - credential_type, - credential_slot, - step_remaining); + zwave_frame learn_start_frame; + learn_start_frame.add(user_id); + learn_start_frame.add(credential_type); + learn_start_frame.add(credential_slot); + learn_start_frame.add(expected_operation_type); + learn_start_frame.add(expected_cl_timeout); - std::map uint8_attribute_map = { - {ATTRIBUTE(CREDENTIAL_LEARN_STATUS), learn_status}, - {ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), step_remaining}, - }; + helper_test_get_set_frame_happy_case(CREDENTIAL_LEARN_START, + operation_type_node, + learn_start_frame); - helper_test_attribute_store_values(uint8_attribute_map, credential_slot_node); + uint8_t step_remaining = 2; + user_credential_learn_status_t learn_status = CREDENTIAL_LEARN_REPORT_SUCCESS; + helper_simulate_learn_status_report_frame(learn_status, + user_id, + credential_type, + credential_slot, + step_remaining); + + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_STATUS), + learn_status, + credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), + step_remaining, + credential_slot_node); }; struct association_nodes_t { - attribute_store_node_t association_user_id_node; - attribute_store_node_t association_credential_slot_node; + attribute_store::attribute association_user_id_node; + attribute_store::attribute association_credential_slot_node; }; association_nodes_t - helper_setup_association(attribute_store_node_t credential_slot_node, + helper_setup_association(attribute_store::attribute credential_slot_node, user_credential_user_unique_id_t destination_user_id, user_credential_slot_t destination_credential_slot) { association_nodes_t association_nodes; - association_nodes.association_user_id_node = attribute_store_emplace_desired( - credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), - &destination_user_id, - sizeof(destination_user_id)); + association_nodes.association_user_id_node + = credential_slot_node.emplace_node( + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + destination_user_id, + DESIRED_ATTRIBUTE); + association_nodes.association_credential_slot_node - = attribute_store_emplace_desired( - credential_slot_node, + = credential_slot_node.emplace_node( ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), - &destination_credential_slot, - sizeof(destination_credential_slot)); + destination_credential_slot, + DESIRED_ATTRIBUTE); return association_nodes; } -void helper_fill_credential_data(attribute_store_node_t credential_slot_node, - std::string credential_data, - user_credential_modifier_type_t modifier_type) +void helper_fill_credential_data( + attribute_store::attribute credential_slot_node, + std::string credential_data, + user_credential_modifier_type_t modifier_type) { - attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - credential_data.data(), - credential_data.size()); - - attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), - &modifier_type, - sizeof(modifier_type)); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + modifier_type); } -void helper_test_credential_data(attribute_store::attribute credential_slot_node, - std::string credential_data, - user_credential_modifier_type_t modifier_type) +void helper_test_credential_data( + attribute_store::attribute credential_slot_node, + std::string credential_data, + user_credential_modifier_type_t modifier_type) { - auto reported_credential_data - = credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA)) - .reported>(); - - TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(credential_data.data(), - reported_credential_data.data(), - credential_data.size(), - "Credential data mismatch"); - - user_credential_modifier_type_t reported_modifier_type; - attribute_store_get_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), - &reported_modifier_type, - sizeof(reported_modifier_type)); - TEST_ASSERT_EQUAL_MESSAGE(modifier_type, - reported_modifier_type, - "Modifier type mismatch"); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_DATA), + credential_data, + credential_slot_node); + + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + modifier_type, + credential_slot_node); } -std::vector helper_create_credential_report_frame( +void helper_simulate_credential_report_frame( user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot, @@ -868,60 +424,35 @@ std::vector helper_create_credential_report_frame( user_credential_modifier_type_t credential_modifier_type, user_credential_modifier_node_id_t credential_modifier_node_id, user_credential_type_t next_credential_type, - user_credential_slot_t next_credential_slot) + user_credential_slot_t next_credential_slot, + sl_status_t expected_status = SL_STATUS_OK) { - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, CREDENTIAL_REPORT}; - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(credential_type); - - auto exploded_credential_slot = explode_uint16(credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); - - report_frame.push_back(crb << 7); - report_frame.push_back(credential_data.size()); - - for (uint8_t credential_value: credential_data) { - report_frame.push_back(credential_value); - } - - report_frame.push_back(credential_modifier_type); - auto exploded_credential_modifier_node_id - = explode_uint16(credential_modifier_node_id); - report_frame.push_back(exploded_credential_modifier_node_id.msb); - report_frame.push_back(exploded_credential_modifier_node_id.lsb); - - report_frame.push_back(next_credential_type); - auto exploded_next_credential_slot = explode_uint16(next_credential_slot); - report_frame.push_back(exploded_next_credential_slot.msb); - report_frame.push_back(exploded_next_credential_slot.lsb); - - return report_frame; + zwave_frame report_frame; + + report_frame.add(user_id); + report_frame.add(credential_type); + report_frame.add(credential_slot); + report_frame.add(static_cast(crb << 7)); + report_frame.add(credential_data); + report_frame.add(credential_modifier_type); + report_frame.add(credential_modifier_node_id); + report_frame.add(next_credential_type); + report_frame.add(next_credential_slot); + + helper_test_report_frame(CREDENTIAL_REPORT, report_frame, expected_status); }; void helper_create_credential_checksum_structure() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - // Since credential are attached to an user we simulate somes users std::vector user_ids = {12, 15, 18}; - std::map + std::map user_id_nodes = {}; for (auto user_id: user_ids) { - user_id_nodes.insert({user_id, - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id))}); + user_id_nodes.insert( + {user_id, + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id)}); } // Create simulated envrionment for credentials @@ -968,80 +499,28 @@ void helper_create_credential_checksum_structure() for (size_t i = 0; i < credential_types.size(); i++) { // Simulate credential type and slot to get the credential report to work auto user_credential_type_node - = attribute_store_emplace(user_id_nodes[credential_user_ids[i]], - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_types[i], - sizeof(credential_types[i])); - attribute_store_emplace(user_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slots[i], - sizeof(credential_slots[i])); - auto credential_frame - = helper_create_credential_report_frame(credential_user_ids[i], - credential_types[i], - credential_slots[i], - 0, - credential_data[i], - 0x02, // Anything but 0 - 0, - 0, - 0); + = user_id_nodes[credential_user_ids[i]].emplace_node( + ATTRIBUTE(CREDENTIAL_TYPE), + credential_types[i]); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, - credential_frame.data(), - credential_frame.size()), - "Credential report should have returned SL_STATUS_OK"); + user_credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slots[i]); + + helper_simulate_credential_report_frame(credential_user_ids[i], + credential_types[i], + credential_slots[i], + 0, + credential_data[i], + 0x02, // Anything but 0 + 0, + 0, + 0); } } ///////////////////////////////////////////////////// // Test case ///////////////////////////////////////////////////// -// Stub functions -static sl_status_t - attribute_resolver_register_rule_stub(attribute_store_type_t node_type, - attribute_resolver_function_t set_func, - attribute_resolver_function_t get_func, - int cmock_num_calls) -{ - std::string message; - std::string node_name = attribute_store_get_type_name(node_type); - - if (attributes_binding.find(node_type) != attributes_binding.end()) { - const auto func = attributes_binding[node_type]; - - if (func.get_func_id == 0) { - message - = "GET function should not be defined for " + node_name - + ". Did you forget to add it to the attributes_binding variable ?"; - TEST_ASSERT_NULL_MESSAGE(get_func, message.c_str()); - } else { - message = "SET function should be defined for " + node_name - + ". Did you forget to remove it to the attributes_binding " - "variable ?"; - TEST_ASSERT_NOT_NULL_MESSAGE(get_func, message.c_str()); - resolver_functions[func.get_func_id] = get_func; - } - - if (func.set_func_id == 0) { - message - = "SET function should not be defined for " + node_name - + ". Did you forget to add it to the attributes_binding variable ?"; - TEST_ASSERT_NULL_MESSAGE(set_func, message.c_str()); - } else { - message = "SET function should be defined for " + node_name - + ". Did you forget to remove it to the attributes_binding " - "variable ?"; - TEST_ASSERT_NOT_NULL_MESSAGE(set_func, message.c_str()); - resolver_functions[func.set_func_id] = set_func; - } - } - - return SL_STATUS_OK; -} - static void zwave_command_class_notification_register_event_callback_stub( attribute_store_node_t endpoint_node, notification_event_callback_t callback, @@ -1050,22 +529,6 @@ static void zwave_command_class_notification_register_event_callback_stub( notification_callback = callback; } -static sl_status_t zwave_command_handler_register_handler_stub( - zwave_command_handler_t new_command_class_handler, int cmock_num_calls) -{ - handler = new_command_class_handler; - - TEST_ASSERT_EQUAL(ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS, - handler.minimal_scheme); - TEST_ASSERT_EQUAL(COMMAND_CLASS_USER_CREDENTIAL, handler.command_class); - TEST_ASSERT_EQUAL(1, handler.version); - TEST_ASSERT_NOT_NULL(handler.control_handler); - TEST_ASSERT_NULL(handler.support_handler); - TEST_ASSERT_FALSE(handler.manual_security_validation); - - return SL_STATUS_OK; -} - /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() { @@ -1087,31 +550,14 @@ void setUp() { zwave_network_management_get_node_id_IgnoreAndReturn(zpc_node_id); zwave_network_management_get_home_id_IgnoreAndReturn(home_id); - zpc_attribute_store_test_helper_create_network(); - // Unset previous definition get/set functions - for (auto &r: resolver_functions) { - r.second = NULL; - } + zwave_setUp(command_class_handler, + &zwave_command_class_user_credential_init, + attributes_binding); notification_callback = NULL; - - memset(received_frame, 0, sizeof(received_frame)); - received_frame_size = 0; - // Unset previous definition of handler - memset(&handler, 0, sizeof(zwave_command_handler_t)); - - // Resolution functions - attribute_resolver_register_rule_Stub(&attribute_resolver_register_rule_stub); - - // Handler registration - zwave_command_handler_register_handler_Stub( - &zwave_command_handler_register_handler_stub); - zwave_command_class_notification_register_event_callback_Stub( &zwave_command_class_notification_register_event_callback_stub); - // Call init - TEST_ASSERT_EQUAL(SL_STATUS_OK, zwave_command_class_user_credential_init()); } /// Called after each and every test @@ -1122,7 +568,7 @@ void tearDown() {} //////////////////////////////////////////////////////////////////////////// void test_user_credential_user_capabilities_get_happy_case() { - helper_test_get_no_args_happy_case(USER_CAPABILITIES_GET); + helper_test_get_set_frame_happy_case(USER_CAPABILITIES_GET); } void test_user_credential_user_capabilities_report_happy_case() @@ -1148,31 +594,23 @@ void test_user_credential_user_capabilities_report_happy_case() supported_user_types_bitmask_length, supported_user_types_bitmask); - // Define data structures - std::map uint8_attribute_map = { - {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), cred_rule_bitmask}, - {ATTRIBUTE(MAX_USERNAME_LENGTH), username_max_length}, - {ATTRIBUTE(SUPPORT_USER_SCHEDULE), support_user_schedule}, - {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), support_all_users_checksum}, - {ATTRIBUTE(SUPPORT_USER_CHECKSUM), support_user_checksum}, - }; - - std::map uint16_attribute_map = { - {ATTRIBUTE(NUMBER_OF_USERS), number_of_users}, - }; - std::map uint32_attribute_map = { - {ATTRIBUTE(SUPPORTED_USER_TYPES), supported_user_types_bitmask}, - }; - - // Test values - helper_test_attribute_store_values(uint8_attribute_map); - helper_test_attribute_store_values(uint16_attribute_map); - helper_test_attribute_store_values(uint32_attribute_map); + helper_test_attribute_value(ATTRIBUTE(NUMBER_OF_USERS), number_of_users); + helper_test_attribute_value(ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), + cred_rule_bitmask); + helper_test_attribute_value(ATTRIBUTE(MAX_USERNAME_LENGTH), + username_max_length); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_USER_SCHEDULE), + support_user_schedule); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), + support_all_users_checksum); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_USER_CHECKSUM), + support_user_checksum); + helper_test_attribute_value(ATTRIBUTE(SUPPORTED_USER_TYPES), + supported_user_types_bitmask); attribute_store_node_t all_user_checksum_node - = attribute_store_get_node_child_by_type(endpoint_id_node, - ATTRIBUTE(ALL_USERS_CHECKSUM), - 0); + = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)); + if (support_all_users_checksum) { TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, all_user_checksum_node, @@ -1219,7 +657,7 @@ void test_user_credential_user_capabilities_report_happy_case() //////////////////////////////////////////////////////////////////////////// void test_user_credential_credential_capabilities_get_happy_case() { - helper_test_get_no_args_happy_case(CREDENTIAL_CAPABILITIES_GET); + helper_test_get_set_frame_happy_case(CREDENTIAL_CAPABILITIES_GET); } void test_user_credential_credential_capabilities_report_happy_case() @@ -1235,46 +673,44 @@ void test_user_credential_credential_capabilities_report_happy_case() uint16_t expected_credential_type_mask = 0b11101; auto test_report_values = [&]() { - std::map uint8_attribute_map - = {{ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), credential_checksum_support}}; - std::map uint16_attribute_map - = {{DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, - expected_credential_type_mask}}; - - helper_test_attribute_store_values(uint8_attribute_map, endpoint_id_node); - helper_test_attribute_store_values(uint16_attribute_map, endpoint_id_node); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + credential_checksum_support); + helper_test_attribute_value( + DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, + expected_credential_type_mask); for (uint8_t i = 0; i < credential_type.size(); i++) { printf("Testing credential batch %d\n", i); - attribute_store_node_t type_node = attribute_store_get_node_child_by_type( - endpoint_id_node, + auto type_node = cpp_endpoint_id_node.child_by_type( ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), i); TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, type_node, "Credential type node should be defined"); - user_credential_type_t reported_credential; - - attribute_store_get_reported(type_node, - &reported_credential, - sizeof(reported_credential)); - TEST_ASSERT_EQUAL_MESSAGE(credential_type[i], - reported_credential, + type_node.reported(), "Incorrect credential type"); - uint8_attribute_map = { - {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), min_length[i]}, - {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), max_length[i]}, - {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), cl_support[i]}, - {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), cl_timeout[i]}, - {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), cl_steps[i]}, - }; - uint16_attribute_map = {{ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), - supported_credential_slots[i]}}; - helper_test_attribute_store_values(uint8_attribute_map, type_node); - helper_test_attribute_store_values(uint16_attribute_map, type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MIN_LENGTH), + min_length[i], + type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MAX_LENGTH), + max_length[i], + type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), + cl_support[i], + type_node); + helper_test_attribute_value( + ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + cl_timeout[i], + type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), + cl_steps[i], + type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), + supported_credential_slots[i], + type_node); } }; @@ -1318,40 +754,20 @@ void test_user_credential_credential_capabilities_report_happy_case() //////////////////////////////////////////////////////////////////////////// void test_user_credential_all_users_checksum_get_happy_case() { - helper_test_get_no_args_happy_case(ALL_USERS_CHECKSUM_GET); + helper_test_get_set_frame_happy_case(ALL_USERS_CHECKSUM_GET); } void test_user_credential_all_users_checksum_report_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - auto create_report_frame - = [&](user_credential_all_users_checksum_t checksum) { - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, ALL_USERS_CHECKSUM_REPORT}; - - auto exploded_checksum = explode_uint16(checksum); - - report_frame.push_back(exploded_checksum.msb); - report_frame.push_back(exploded_checksum.lsb); - - return report_frame; - }; - user_credential_all_users_checksum_t expected_checksum = 0xABCD; - auto report_frame = create_report_frame(expected_checksum); - - TEST_ASSERT_EQUAL( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size())); + // Report frame + zwave_frame report_frame; + report_frame.add(expected_checksum); + helper_test_report_frame(ALL_USERS_CHECKSUM_REPORT, report_frame); - std::map uint16_attribute_map - = {{ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum}}; - helper_test_attribute_store_values(uint16_attribute_map); + // Attribute store test + helper_test_attribute_value(ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum); } //////////////////////////////////////////////////////////////////////////// @@ -1368,124 +784,100 @@ void test_user_credential_user_set_add_or_modify_happy_case() user_credential_user_name_encoding_t user_name_encoding = 0; std::string user_name = "DoUzE"; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + // Create structure + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); auto operation_type_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); - auto user_type_node = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_TYPE), - &user_type, - sizeof(user_type)); - auto user_active_state_node - = attribute_store_emplace(user_id_node, - ATTRIBUTE(USER_ACTIVE_STATE), - &user_active_state, - sizeof(user_active_state)); - auto credential_rule_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_RULE), - &credential_rule, - sizeof(credential_rule)); - auto expiring_timeout_node - = attribute_store_emplace(user_id_node, - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - &expiring_timeout, - sizeof(expiring_timeout)); - auto user_name_encoding_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_NAME_ENCODING), - &user_name_encoding, - sizeof(user_name_encoding)); - auto user_name_node - = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); - - sl_status_t status - = attribute_store_set_reported_string(user_name_node, user_name.c_str()); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, "Can't set username"); + = user_id_node.emplace_node(ATTRIBUTE(USER_OPERATION_TYPE), + operation_type, + DESIRED_ATTRIBUTE); + user_id_node.emplace_node(ATTRIBUTE(USER_TYPE), user_type, DESIRED_ATTRIBUTE); + user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE), user_active_state); + user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE), + credential_rule, + DESIRED_ATTRIBUTE); + user_id_node.emplace_node(ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + expiring_timeout); + user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING), + user_name_encoding, + DESIRED_ATTRIBUTE); + user_id_node.emplace_node(ATTRIBUTE(USER_NAME), user_name); + + auto create_and_send_set_frame = [&]() { + zwave_frame set_frame; + set_frame.add(operation_type); + set_frame.add(user_id); + set_frame.add(user_type); + set_frame.add(user_active_state); + set_frame.add(credential_rule); + set_frame.add(expiring_timeout); + set_frame.add(user_name_encoding); + set_frame.add(user_name); + + helper_test_get_set_frame_happy_case(USER_SET, + operation_type_node, + set_frame); + }; - printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); - helper_test_set_get_with_args(USER_SET, - operation_type_node, - {{operation_type_node, DESIRED_ATTRIBUTE}, - {user_id_node, REPORTED_ATTRIBUTE}, - {user_type_node, DESIRED_ATTRIBUTE}, - {user_active_state_node, REPORTED_ATTRIBUTE}, - {credential_rule_node, DESIRED_ATTRIBUTE}, - {expiring_timeout_node, REPORTED_ATTRIBUTE}, - {user_name_encoding_node, DESIRED_ATTRIBUTE}, - {user_name_node, REPORTED_ATTRIBUTE}}); + // Test user set + printf("Send with USER_SET_OPERATION_TYPE_ADD\n"); + create_and_send_set_frame(); printf("Send with USER_SET_OPERATION_TYPE_MODIFY\n"); - - operation_type = USER_SET_OPERATION_TYPE_ADD; - attribute_store_set_desired(operation_type_node, - &operation_type, - sizeof(operation_type)); - helper_test_set_get_with_args(USER_SET, - operation_type_node, - {{operation_type_node, DESIRED_ATTRIBUTE}, - {user_id_node, REPORTED_ATTRIBUTE}, - {user_type_node, DESIRED_ATTRIBUTE}, - {user_active_state_node, REPORTED_ATTRIBUTE}, - {credential_rule_node, DESIRED_ATTRIBUTE}, - {expiring_timeout_node, REPORTED_ATTRIBUTE}, - {user_name_encoding_node, DESIRED_ATTRIBUTE}, - {user_name_node, REPORTED_ATTRIBUTE}}); + operation_type = USER_SET_OPERATION_TYPE_MODIFY; + operation_type_node.set_desired(operation_type); + create_and_send_set_frame(); } -void test_user_credential_user_delete_remove_happy_case() +void test_user_credential_user_delete_happy_case() { user_credential_user_unique_id_t user_id = 12121; user_credential_operation_type_t operation_type = USER_SET_OPERATION_TYPE_DELETE; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); auto operation_type_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); - - helper_test_set_get_with_args(USER_SET, - operation_type_node, - {{operation_type_node, DESIRED_ATTRIBUTE}, - {user_id_node, REPORTED_ATTRIBUTE}}); + = user_id_node.emplace_node(ATTRIBUTE(USER_OPERATION_TYPE), + operation_type, + DESIRED_ATTRIBUTE); + + zwave_frame set_frame; + set_frame.add(operation_type); + set_frame.add(user_id); + + helper_test_get_set_frame_happy_case(USER_SET, + operation_type_node, + set_frame); } void test_user_credential_user_set_invalid_node() { - helper_test_set_get_with_args(USER_SET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_get_set_fail_case(USER_GET, SL_STATUS_NOT_SUPPORTED); } void test_user_credential_user_get_happy_case() { user_credential_user_unique_id_t user_id = 12; - auto user_node = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - helper_test_set_get_with_args(USER_GET, - user_node, - {{user_node, DESIRED_ATTRIBUTE}}); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + + zwave_frame get_frame; + get_frame.add(user_id); + + helper_test_get_set_frame_happy_case(USER_GET, user_id_node, get_frame); } void test_user_credential_user_get_not_found() { - helper_test_set_get_with_args(USER_GET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_get_set_fail_case(USER_GET, SL_STATUS_NOT_SUPPORTED); } -std::vector helper_create_user_report_frame( +void helper_simulate_user_report_frame( uint8_t user_report_type, user_credential_user_unique_id_t next_user_id, user_credential_modifier_type_t user_modifier_type, @@ -1496,74 +888,25 @@ std::vector helper_create_user_report_frame( user_credential_supported_credential_rules_t credential_rule, user_credential_expiring_timeout_minutes_t expiring_timeout_minutes, user_credential_user_name_encoding_t user_name_encoding, - std::string user_name) -{ - std::vector report_frame - = {COMMAND_CLASS_USER_CREDENTIAL, USER_REPORT}; - - report_frame.push_back(user_report_type); - - auto exploded_next_user_id = explode_uint16(next_user_id); - report_frame.push_back(exploded_next_user_id.msb); - report_frame.push_back(exploded_next_user_id.lsb); - - report_frame.push_back(user_modifier_type); - - auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); - report_frame.push_back(exploded_user_modifier_node_id.msb); - report_frame.push_back(exploded_user_modifier_node_id.lsb); - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(user_type); - report_frame.push_back(user_active_state); - report_frame.push_back(credential_rule); - - auto exploded_time = explode_uint16(expiring_timeout_minutes); - report_frame.push_back(exploded_time.msb); - report_frame.push_back(exploded_time.lsb); - - report_frame.push_back(user_name_encoding); - report_frame.push_back(user_name.size()); - for (char c: user_name) { - report_frame.push_back(c); - } - return report_frame; -}; - -std::vector helper_create_user_notification_report( - user_credential_modifier_type_t user_modifier_type, - user_credential_modifier_node_id_t user_modifier_node_id, - user_credential_user_unique_id_t user_id, - user_credential_user_type_t user_type, - user_credential_user_active_state_t user_active_state, - user_credential_supported_credential_rules_t credential_rule, - user_credential_expiring_timeout_minutes_t expiring_timeout_minutes) + const std::string &user_name, + sl_status_t expected_status = SL_STATUS_OK) { - std::vector report_frame; - - report_frame.push_back(user_modifier_type); - - auto exploded_user_modifier_node_id = explode_uint16(user_modifier_node_id); - report_frame.push_back(exploded_user_modifier_node_id.msb); - report_frame.push_back(exploded_user_modifier_node_id.lsb); - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(user_type); - report_frame.push_back(user_active_state); - report_frame.push_back(credential_rule); - - auto exploded_time = explode_uint16(expiring_timeout_minutes); - report_frame.push_back(exploded_time.msb); - report_frame.push_back(exploded_time.lsb); - - return report_frame; -}; + zwave_frame report_frame; + report_frame.add(user_report_type); + report_frame.add(next_user_id); + report_frame.add(user_modifier_type); + report_frame.add(user_modifier_node_id); + report_frame.add(user_id); + report_frame.add(user_type); + report_frame.add(user_active_state); + report_frame.add(credential_rule); + report_frame.add(expiring_timeout_minutes); + report_frame.add(user_name_encoding); + report_frame.add(user_name); + + // Use helper function to get the report frame + helper_test_report_frame(USER_REPORT, report_frame, expected_status); +} // FIXME: Will be changed // https://github.com/Z-Wave-Alliance/AWG/issues/168 @@ -1576,44 +919,21 @@ std::vector helper_create_credential_notification_report( user_credential_modifier_type_t modifier_type, user_credential_modifier_node_id_t modifier_node_id) { - std::vector report_frame; - - auto exploded_user_id = explode_uint16(user_id); - report_frame.push_back(exploded_user_id.msb); - report_frame.push_back(exploded_user_id.lsb); - - report_frame.push_back(credential_type); - - auto exploded_credential_slot = explode_uint16(credential_slot); - report_frame.push_back(exploded_credential_slot.msb); - report_frame.push_back(exploded_credential_slot.lsb); + zwave_frame report_frame; - report_frame.push_back(crb ? 1 : 0); - report_frame.push_back(credential_data.size()); - - for (auto &c: credential_data) { - report_frame.push_back(c); - } - - report_frame.push_back(modifier_type); - - auto exploded_modifier_node_id = explode_uint16(modifier_node_id); - report_frame.push_back(exploded_modifier_node_id.msb); - report_frame.push_back(exploded_modifier_node_id.lsb); + report_frame.add(user_id); + report_frame.add(credential_type); + report_frame.add(credential_slot); + report_frame.add(static_cast(crb ? 1 : 0)); + report_frame.add(credential_data); + report_frame.add(modifier_type); + report_frame.add(modifier_node_id); return report_frame; }; void test_user_credential_user_report_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - auto user_get = resolver_functions[USER_GET]; - TEST_ASSERT_NOT_NULL_MESSAGE(user_get, "User get function should be defined"); - constexpr user_credential_user_unique_id_t EXPECTED_FIRST_USER_ID = 12; constexpr user_credential_user_unique_id_t EXPECTED_SECOND_USER_ID = 1212; @@ -1628,53 +948,42 @@ void test_user_credential_user_report_happy_case() user_credential_user_name_encoding_t user_name_encoding = 0; std::string user_name = "DoUzE"; - auto test_user_values = [&](attribute_store_node_t user_node) { - // Check main node value - user_credential_user_unique_id_t reported_id; - attribute_store_get_reported(user_node, &reported_id, sizeof(reported_id)); - TEST_ASSERT_EQUAL_MESSAGE(user_id, - reported_id, - "User Unique ID is incorrect"); - // Then test values underneath - std::map uint8_attribute_map - = {{ATTRIBUTE(USER_MODIFIER_TYPE), user_modifier_type}, - {ATTRIBUTE(USER_TYPE), user_type}, - {ATTRIBUTE(USER_ACTIVE_STATE), user_active_state}, - {ATTRIBUTE(CREDENTIAL_RULE), credential_rule}}; - helper_test_attribute_store_values(uint8_attribute_map, user_node); - - std::map uint16_attribute_map - = {{ATTRIBUTE(USER_MODIFIER_NODE_ID), user_modifier_node_id}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), expiring_timeout_minutes}}; - helper_test_attribute_store_values(uint16_attribute_map, user_node); - - helper_test_string_value({{ATTRIBUTE(USER_NAME), user_name}}, user_node); + auto test_user_values = [&](const attribute_store::attribute &user_node) { + TEST_ASSERT_EQUAL_MESSAGE( + user_id, + user_node.reported(), + "User Unique ID is incorrect"); + + helper_test_attribute_value(ATTRIBUTE(USER_MODIFIER_TYPE), + user_modifier_type, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_TYPE), user_type, user_node); + helper_test_attribute_value(ATTRIBUTE(USER_ACTIVE_STATE), + user_active_state, + user_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_RULE), + credential_rule, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + expiring_timeout_minutes, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_NAME_ENCODING), + user_name_encoding, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_NAME), user_name, user_node); + helper_test_attribute_value(ATTRIBUTE(USER_MODIFIER_NODE_ID), + user_modifier_node_id, + user_node); // Check user credential desired values - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 12; auto credential_type_node - = attribute_store_get_node_child_by_type(user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - 0); - attribute_store_get_reported(credential_type_node, - &credential_type, - sizeof(credential_type)); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - credential_type_node, - "credential_type_node should exist"); - - auto credential_slot_node - = attribute_store_get_node_child_by_type(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - 0); - attribute_store_get_desired(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); - - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - credential_slot_node, - "credential_slot_node should exist"); + = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_TYPE), user_node); + + auto credential_type + = credential_type_node.reported(); + auto credential_slot = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_type_node) + .desired(); TEST_ASSERT_EQUAL_MESSAGE( 0, @@ -1686,53 +995,39 @@ void test_user_credential_user_report_happy_case() "Credential Slot should be at 0 and should exists"); }; // end test_user_values lambda - // Todo : update this value with define from zw_cmdclass.h when updated - auto report_frame = helper_create_user_report_frame(0x04, - next_user_id, - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout_minutes, - user_name_encoding, - user_name); - printf("First user creation\n"); // Create first user auto first_user_id_node - = attribute_store_add_node(ATTRIBUTE(USER_UNIQUE_ID), endpoint_id_node); - // First user should have ID 0 and then set in the report - user_credential_user_unique_id_t first_id = 0; - attribute_store_set_desired(first_user_id_node, &first_id, sizeof(first_id)); + = cpp_endpoint_id_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)); + first_user_id_node.set_desired(0); - // Simulate get on that user - sl_status_t user_get_status - = user_get(first_user_id_node, received_frame, &received_frame_size); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - user_get_status, - "User get should have returned SL_STATUS_OK"); + zwave_frame get_frame; + get_frame.add(static_cast(0)); + helper_test_get_set_frame_happy_case(USER_GET, first_user_id_node, get_frame); // Call report - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "User Report should have returned SL_STATUS_OK"); + helper_simulate_user_report_frame(0x04, + next_user_id, + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout_minutes, + user_name_encoding, + user_name); + // Test values - // For the first + // For the first first_user_id_node - = attribute_store_get_node_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - 1); + = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(USER_UNIQUE_ID), 1); test_user_values(first_user_id_node); // Test structure auto user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); TEST_ASSERT_EQUAL_MESSAGE( 3, user_id_count, @@ -1740,30 +1035,22 @@ void test_user_credential_user_report_happy_case() "reported one and the new desired one"); auto second_user_id_node - = attribute_store_get_node_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - 2); + = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(USER_UNIQUE_ID), 2); printf("Second and last user creation\n"); - // Check second & not defined user id - user_credential_user_unique_id_t second_user_id; - attribute_store_get_desired(second_user_id_node, - &second_user_id, - sizeof(second_user_id)); TEST_ASSERT_EQUAL_MESSAGE( next_user_id, - second_user_id, + second_user_id_node.desired(), "Second user id should have it's desired value defined"); // Simulate a GET on that user // Removes the desired state and sets to reported instead - user_get_status - = user_get(second_user_id_node, received_frame, &received_frame_size); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - user_get_status, - "User get should have returned SL_STATUS_OK"); + get_frame.clear(); + get_frame.add(next_user_id); + helper_test_get_set_frame_happy_case(USER_GET, + second_user_id_node, + get_frame); // Second and last user next_user_id = 0; @@ -1776,68 +1063,49 @@ void test_user_credential_user_report_happy_case() user_name_encoding = 1; user_name = "NoDoUzE4YoU"; - report_frame = helper_create_user_report_frame(0x04, - next_user_id, - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout_minutes, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Second User Report should have returned SL_STATUS_OK"); + helper_simulate_user_report_frame(0x04, + next_user_id, + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout_minutes, + user_name_encoding, + user_name); // Test values test_user_values(second_user_id_node); // Test structure // The report function should not have created an other user unique id node (next_user_id = 0) user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); - TEST_ASSERT_EQUAL_MESSAGE(3, - user_id_count, - "User node count mismatch. Should only 2 users + 1 with id 0 created."); - - user_credential_user_unique_id_t reported_id; - attribute_store_get_reported(first_user_id_node, - &reported_id, - sizeof(reported_id)); - TEST_ASSERT_EQUAL_MESSAGE(EXPECTED_FIRST_USER_ID, - reported_id, - "First user id mismatch"); - attribute_store_get_reported(second_user_id_node, - &reported_id, - sizeof(reported_id)); - TEST_ASSERT_EQUAL_MESSAGE(EXPECTED_SECOND_USER_ID, - reported_id, - "Second user id mismatch"); -} + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + TEST_ASSERT_EQUAL_MESSAGE( + 3, + user_id_count, + "User node count mismatch. Should only 2 users + 1 with id 0 created."); + + TEST_ASSERT_EQUAL_MESSAGE( + EXPECTED_FIRST_USER_ID, + first_user_id_node.reported(), + "First user id mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + EXPECTED_SECOND_USER_ID, + second_user_id_node.reported(), + "Second user id mismatch"); +} void test_user_credential_user_report_user_with_id0() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - auto report_frame - = helper_create_user_report_frame(0x04, 0, 0, 0, 0, 0, 0, 0, 0, 0, "DOUZE"); - - // Not found since we haven't created any user_unique_id - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "User Report should have returned SL_STATUS_OK and ignore the frame"); + // User Report should have returned SL_STATUS_OK and ignore the frame + helper_simulate_user_report_frame(0x04, 0, 0, 0, 0, 0, 0, 0, 0, 0, "DOUZE"); // Check that no user_unique_id node has been created (and the invalid node was deleted) auto user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + TEST_ASSERT_EQUAL_MESSAGE(0, user_id_count, "No user_unique_id node should be created"); @@ -1845,337 +1113,203 @@ void test_user_credential_user_report_user_with_id0() void test_user_credential_user_report_user_deleted() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - // Create user id with reported ID of 0 to simulate user get of id 0 user_credential_user_unique_id_t user_id = 12; - auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - user_id_node, - "User ID node should be created"); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); auto user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); TEST_ASSERT_EQUAL_MESSAGE(1, user_id_count, "Should have one user by now"); - auto report_frame = helper_create_user_report_frame(0x04, - user_id, - USER_REPORT_DNE, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - "????"); - // Should delete this user - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "User Report should have returned SL_STATUS_NOT_SUPPORTED"); + helper_simulate_user_report_frame(0x04, + user_id, + USER_REPORT_DNE, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + "????"); user_id_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); TEST_ASSERT_EQUAL_MESSAGE(1, user_id_count, "Should not have any user by now"); } - -void test_user_credential_user_added_happy_case() { - -} - //////////////////////////////////////////////////////////////////////////// // Credential Set/Get/Report //////////////////////////////////////////////////////////////////////////// -//>> Set -void test_user_credential_credential_set_1byte_happy_case() +void helper_test_credential_set( + user_credential_operation_type_t operation_type, + std::vector credential_data, + attribute_store_node_value_state_t credential_data_state) { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type - = USER_CREDENTIAL_OPERATION_TYPE_ADD; - std::vector credential_data = {12}; + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; // Create the node with reported attribute - auto nodes = helper_create_credential_structure(12, + auto nodes = helper_create_credential_structure(user_id, credential_type, credential_slot, REPORTED_ATTRIBUTE); - auto user_node = nodes.user_id_node; - auto credential_type_node = nodes.credential_type_node; auto credential_slot_node = nodes.credential_slot_node; // Operation type auto operation_type_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); + = credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type, + DESIRED_ATTRIBUTE); // CREDENTIAL_DATA - auto credential_data_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - credential_data.data(), - credential_data.size()); - - helper_test_set_get_with_args(CREDENTIAL_SET, - operation_type_node, - { - {user_node, REPORTED_ATTRIBUTE}, - {credential_type_node, REPORTED_ATTRIBUTE}, - {credential_slot_node, REPORTED_ATTRIBUTE}, - {operation_type_node, DESIRED_ATTRIBUTE}, - {credential_data_node, DESIRED_ATTRIBUTE}, - }); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data, + credential_data_state); + + zwave_frame set_frame; + set_frame.add(user_id); + set_frame.add(credential_type); + set_frame.add(credential_slot); + set_frame.add(operation_type); + if (credential_data.size() > 0) { + set_frame.add(credential_data); + } else { + set_frame.add(static_cast(0x00)); + } + + helper_test_get_set_frame_happy_case(CREDENTIAL_SET, + operation_type_node, + set_frame); } -void test_user_credential_credential_set_12byte_happy_case() +//>> Set +void test_user_credential_credential_set_1byte_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type - = USER_CREDENTIAL_OPERATION_TYPE_MODIFY; - std::vector credential_data - = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - - // Create the node with reported attribute - auto nodes = helper_create_credential_structure(12, - credential_type, - credential_slot, - REPORTED_ATTRIBUTE); - auto user_node = nodes.user_id_node; - auto credential_type_node = nodes.credential_type_node; - auto credential_slot_node = nodes.credential_slot_node; + helper_test_credential_set(USER_CREDENTIAL_OPERATION_TYPE_ADD, + {12}, + REPORTED_ATTRIBUTE); +} - // Operation type - auto operation_type_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); - // CREDENTIAL_DATA - auto credential_data_node - = attribute_store_emplace(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - credential_data.data(), - credential_data.size()); - - helper_test_set_get_with_args(CREDENTIAL_SET, - operation_type_node, - { - {user_node, REPORTED_ATTRIBUTE}, - {credential_type_node, REPORTED_ATTRIBUTE}, - {credential_slot_node, REPORTED_ATTRIBUTE}, - {operation_type_node, DESIRED_ATTRIBUTE}, - {credential_data_node, REPORTED_ATTRIBUTE}, - }); +void test_user_credential_credential_set_12byte_happy_case() +{ + helper_test_credential_set(USER_CREDENTIAL_OPERATION_TYPE_ADD, + {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, + DESIRED_ATTRIBUTE); } void test_user_credential_credential_set_invalid_node() { - helper_test_set_get_with_args(CREDENTIAL_SET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_get_set_fail_case(CREDENTIAL_SET); } void test_user_credential_credential_set_delete_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; - user_credential_operation_type_t operation_type - = USER_CREDENTIAL_OPERATION_TYPE_DELETE; - - // Create the node with reported attribute - auto nodes = helper_create_credential_structure(12, - credential_type, - credential_slot, - REPORTED_ATTRIBUTE); - auto user_node = nodes.user_id_node; - auto credential_type_node = nodes.credential_type_node; - auto credential_slot_node = nodes.credential_slot_node; - - // Operation type - auto operation_type_node - = attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &operation_type, - sizeof(operation_type)); - - helper_test_set_get_with_args(CREDENTIAL_SET, - operation_type_node, - { - {user_node, REPORTED_ATTRIBUTE}, - {credential_type_node, REPORTED_ATTRIBUTE}, - {credential_slot_node, REPORTED_ATTRIBUTE}, - {operation_type_node, DESIRED_ATTRIBUTE}, - }, - {0x00} // Credential data length + helper_test_credential_set(USER_CREDENTIAL_OPERATION_TYPE_DELETE, + {}, // Empty credential data + DESIRED_ATTRIBUTE // doesn't matter here ); } //>> Get - void test_user_credential_credential_get_happy_case() { - user_credential_type_t credential_type = 2; - user_credential_slot_t credential_slot = 1212; + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 2; + user_credential_slot_t credential_slot = 1212; - auto nodes - = helper_create_credential_structure(12, credential_type, credential_slot); - auto user_node = nodes.user_id_node; - auto credential_type_node = nodes.credential_type_node; - auto credential_slot_node = nodes.credential_slot_node; + auto nodes = helper_create_credential_structure(user_id, + credential_type, + credential_slot); + + zwave_frame get_frame; + get_frame.add(user_id); + get_frame.add(credential_type); + get_frame.add(credential_slot); - // Get should make both credential_type_node and credential_slot_node reported value as the desired values - helper_test_set_get_with_args(CREDENTIAL_GET, - credential_slot_node, - { - {user_node, REPORTED_ATTRIBUTE}, - {credential_type_node, REPORTED_ATTRIBUTE}, - {credential_slot_node, DESIRED_ATTRIBUTE}, - }); + helper_test_get_set_frame_happy_case(CREDENTIAL_GET, + nodes.credential_slot_node, + get_frame); } void test_user_credential_credential_get_no_credential_type() { - helper_test_set_get_with_args(CREDENTIAL_GET, ATTRIBUTE_STORE_INVALID_NODE); + helper_test_get_set_fail_case(CREDENTIAL_GET, SL_STATUS_NOT_SUPPORTED); } void test_user_credential_credential_report_no_credential() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - user_id_node, - "User ID node should be defined"); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - auto report_frame - = helper_create_credential_report_frame(user_id, 0, 0, 0, {}, 0, 0, 0, 0); - - // SHould return ok since credential_type and credential node is 0 - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); + // Should return ok since credential_type and credential node is 0 + helper_simulate_credential_report_frame(user_id, 0, 0, 0, {}, 0, 0, 0, 0); } void test_user_credential_credential_report_missing_user() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - auto report_frame - = helper_create_credential_report_frame(12, 1, 1, 0, {}, 0, 0, 0, 0); - // Not found since we haven't created any user_unique_id - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_NOT_SUPPORTED, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); + helper_simulate_credential_report_frame(12, + 1, + 1, + 0, + {}, + 0, + 0, + 0, + 0, + SL_STATUS_NOT_SUPPORTED); } void test_user_credential_credential_report_missing_credential_type() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - user_id_node, - "User ID node should be defined"); - - auto report_frame - = helper_create_credential_report_frame(user_id, 1, 5, 0, {}, 0, 0, 0, 0); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Not found since we haven't created any credential_type - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_NOT_SUPPORTED, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); + helper_simulate_credential_report_frame(user_id, + 1, + 5, + 0, + {}, + 0, + 0, + 0, + 0, + SL_STATUS_NOT_SUPPORTED); } void test_user_credential_credential_report_missing_credential_slot() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - user_id_node, - "User ID node should be defined"); - user_credential_type_t credential_type = 121; - auto credential_type_node - = attribute_store_emplace(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - credential_type_node, - "Credential type node should be defined"); - - auto report_frame = helper_create_credential_report_frame(user_id, - credential_type, - 1212, - 0, - {}, - 0, - 0, - 0, - 0); + user_credential_type_t credential_type = 121; + + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); // Not found since we haven't created any credential_slot - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_NOT_SUPPORTED, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Credential Report should have returned SL_STATUS_NOT_SUPPORTED"); + helper_simulate_credential_report_frame(user_id, + credential_type, + 1212, + 0, + {}, + 0, + 0, + 0, + 0, + SL_STATUS_NOT_SUPPORTED); } void test_user_credential_credential_report_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - auto credential_get = resolver_functions[CREDENTIAL_GET]; - TEST_ASSERT_NOT_NULL_MESSAGE(credential_get, - "Credential get function should be defined"); - user_credential_user_unique_id_t user_id = 122; user_credential_type_t credential_type = 12; user_credential_slot_t credential_slot = 1212; @@ -2186,126 +1320,78 @@ void test_user_credential_credential_report_happy_case() user_credential_type_t next_credential_type = 12; user_credential_slot_t next_credential_slot = 1; - auto test_user_values = [&](attribute_store_node_t credential_type_node, - attribute_store_node_t credential_slot_node) { - // Check main node value - user_credential_type_t reported_cred_type; - attribute_store_get_reported(credential_type_node, - &reported_cred_type, - sizeof(reported_cred_type)); - TEST_ASSERT_EQUAL_MESSAGE(credential_type, - reported_cred_type, - "Credential type value mismatch"); - - user_credential_slot_t reported_cred_slot; - attribute_store_get_reported(credential_slot_node, - &reported_cred_slot, - sizeof(reported_cred_slot)); - TEST_ASSERT_EQUAL_MESSAGE(credential_slot, - reported_cred_slot, - "Credential slot value mismatch"); - - // Then test values underneath - std::map uint8_attribute_map - = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}, - {ATTRIBUTE(CREDENTIAL_READ_BACK), crb}}; - helper_test_attribute_store_values(uint8_attribute_map, - credential_slot_node); - - std::map uint16_attribute_map - = {{ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), credential_modifier_node_id}}; - helper_test_attribute_store_values(uint16_attribute_map, - credential_slot_node); - - - size_t reported_credential_length = credential_data.size(); - std::vector reported_credential_data; - reported_credential_data.resize(reported_credential_length); - - attribute_store_get_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - reported_credential_data.data(), - reported_credential_length); - - TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(credential_data.data(), - reported_credential_data.data(), - credential_data.size(), - "Credential data mismatch"); - }; // end test_user_values lambda + auto test_credential_values + = [&](const attribute_store::attribute &credential_type_node, + const attribute_store::attribute &credential_slot_node) { + // Check main node value + TEST_ASSERT_EQUAL_MESSAGE( + credential_type, + credential_type_node.reported(), + "Credential type value mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + credential_slot, + credential_slot_node.reported(), + "Credential slot value mismatch"); + + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_READ_BACK), + crb, + credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + credential_modifier_type, + credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), + credential_modifier_node_id, + credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_DATA), + credential_data, + credential_slot_node); + }; // end test_credential_values lambda + + auto check_credentials_node_count + = [](const attribute_store::attribute &user_id_node, + size_t expected_credential_type_count, + size_t expected_credential_slot_count) { + auto count_credential_type + = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)).size(); + TEST_ASSERT_EQUAL_MESSAGE(expected_credential_type_count, + count_credential_type, + "Incorrect credential type count"); + + size_t count_credential_slot = 0; + for (size_t i = 0; i < count_credential_type; i++) { + auto credential_type_node + = user_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_TYPE), i); + count_credential_slot + += credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT)).size(); + } - auto check_credentials_node_count = - [](attribute_store_node_t user_id_node, - size_t expected_credential_type_count, - size_t expected_credential_slot_count) { - auto count_credential_type = attribute_store_get_node_child_count_by_type( - user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - TEST_ASSERT_EQUAL_MESSAGE(expected_credential_type_count, - count_credential_type, - "Incorrect credential type count"); - - size_t count_credential_slot = 0; - for (size_t i = 0; i < count_credential_type; i++) { - auto credential_type_node - = attribute_store_get_node_child_by_type(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - i); - count_credential_slot += attribute_store_get_node_child_count_by_type( - credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - } - - TEST_ASSERT_EQUAL_MESSAGE(expected_credential_slot_count, - count_credential_slot, - "Incorrect credential slot count"); - }; + TEST_ASSERT_EQUAL_MESSAGE(expected_credential_slot_count, + count_credential_slot, + "Incorrect credential slot count"); + }; auto check_next_credential_node_value - = [&](attribute_store_node_t next_credential_type_node, - attribute_store_node_t next_credential_slot_node) { + = [&](const attribute_store::attribute &next_credential_type_node, + const attribute_store::attribute &next_credential_slot_node) { // First check node existence - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - next_credential_type_node, - "next_credential_type_node should exist"); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - next_credential_slot_node, - "next_credential_slot_node should exist"); - - user_credential_type_t reported_next_credential_type = 0; - user_credential_slot_t reported_next_credential_slot = 0; - - attribute_store_read_value(next_credential_type_node, - REPORTED_ATTRIBUTE, - &reported_next_credential_type, - sizeof(reported_next_credential_type)); - - attribute_store_read_value(next_credential_slot_node, - DESIRED_ATTRIBUTE, - &reported_next_credential_slot, - sizeof(reported_next_credential_slot)); - - TEST_ASSERT_EQUAL_MESSAGE(next_credential_type, - reported_next_credential_type, - "Next Credential Type value mismatch"); - TEST_ASSERT_EQUAL_MESSAGE(next_credential_slot, - reported_next_credential_slot, - "Next Credential Slot value mismatch"); + TEST_ASSERT_TRUE_MESSAGE(next_credential_type_node.is_valid(), + "next_credential_type_node should exist"); + TEST_ASSERT_TRUE_MESSAGE(next_credential_slot_node.is_valid(), + "next_credential_slot_node should exist"); + + TEST_ASSERT_EQUAL_MESSAGE( + next_credential_type, + next_credential_type_node.reported(), + "Next Credential Type value mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + next_credential_slot, + next_credential_slot_node.desired(), + "Next Credential Slot value mismatch"); }; //>>>> First credential printf("First credential creation\n"); - auto report_frame - = helper_create_credential_report_frame(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id, - next_credential_type, - next_credential_slot); - // Create first credential auto nodes = helper_create_credential_structure(user_id, 0, 0, DESIRED_ATTRIBUTE); @@ -2316,31 +1402,36 @@ void test_user_credential_credential_report_happy_case() attribute_store_log(); - // Simulate get on that credential - sl_status_t credential_get_status = credential_get(first_credential_slot_node, - received_frame, - &received_frame_size); + zwave_frame get_frame; + get_frame.add(user_id); + get_frame.add(static_cast(0)); + get_frame.add(static_cast(0)); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - credential_get_status, - "First Credential get should have returned SL_STATUS_OK"); + // Simulate get on that credential + helper_test_get_set_frame_happy_case(CREDENTIAL_GET, + first_credential_slot_node, + get_frame); // Call report - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "First Credential Report should have returned SL_STATUS_OK"); + helper_simulate_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + // Test values - test_user_values(first_credential_type_node, first_credential_slot_node); + test_credential_values(first_credential_type_node, + first_credential_slot_node); // We should have 1 credential type and 2 credential slot check_credentials_node_count(user_id_node, 1, 2); // Test if next credentials are well defined auto second_credential_slot_node - = attribute_store_get_node_child_by_type(first_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - 1); + = first_credential_type_node.child_by_type(ATTRIBUTE(CREDENTIAL_SLOT), 1); check_next_credential_node_value(first_credential_type_node, second_credential_slot_node); @@ -2356,44 +1447,36 @@ void test_user_credential_credential_report_happy_case() next_credential_type = 121; next_credential_slot = 3; - report_frame - = helper_create_credential_report_frame(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id, - next_credential_type, - next_credential_slot); - // Simulate get on that credential - credential_get_status = credential_get(second_credential_slot_node, - received_frame, - &received_frame_size); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - credential_get_status, - "Credential get should have returned SL_STATUS_OK"); + get_frame.clear(); + get_frame.add(user_id); + get_frame.add(credential_type); + get_frame.add(credential_slot); + helper_test_get_set_frame_happy_case(CREDENTIAL_GET, + second_credential_slot_node, + get_frame); // Call report - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Second Credential Report should have returned SL_STATUS_OK"); + helper_simulate_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + // Test values - test_user_values(first_credential_type_node, second_credential_slot_node); + test_credential_values(first_credential_type_node, + second_credential_slot_node); // We should have 2 credential type and 2 credential slot check_credentials_node_count(user_id_node, 2, 3); auto second_credential_type_node - = attribute_store_get_node_child_by_type(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - 1); + = user_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_TYPE), 1); auto third_credential_slot_node - = attribute_store_get_node_child_by_type(second_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - 0); + = second_credential_type_node.child_by_type(ATTRIBUTE(CREDENTIAL_SLOT), 0); // New nodes so we check their desired values check_next_credential_node_value(second_credential_type_node, @@ -2410,33 +1493,29 @@ void test_user_credential_credential_report_happy_case() next_credential_type = 0; next_credential_slot = 0; - report_frame - = helper_create_credential_report_frame(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id, - next_credential_type, - next_credential_slot); - // Simulate get on that credential - credential_get_status = credential_get(third_credential_slot_node, - received_frame, - &received_frame_size); - - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - credential_get_status, - "Credential get should have returned SL_STATUS_OK"); + get_frame.clear(); + get_frame.add(user_id); + get_frame.add(credential_type); + get_frame.add(credential_slot); + helper_test_get_set_frame_happy_case(CREDENTIAL_GET, + third_credential_slot_node, + get_frame); // Call report - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, report_frame.data(), report_frame.size()), - "Second Credential Report should have returned SL_STATUS_OK"); + helper_simulate_credential_report_frame(user_id, + credential_type, + credential_slot, + crb, + credential_data, + credential_modifier_type, + credential_modifier_node_id, + next_credential_type, + next_credential_slot); + // Test values - test_user_values(second_credential_type_node, third_credential_slot_node); + test_credential_values(second_credential_type_node, + third_credential_slot_node); // We should still have 2 credential type and 3 credential slots since it was the last credential check_credentials_node_count(user_id_node, 2, 3); } @@ -2446,11 +1525,7 @@ void test_user_credential_credential_report_happy_case() //////////////////////////////////////////////////////////////////////////// void test_attribute_creation_happy_case() { - zwave_cc_version_t version = 1; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); std::vector created_types = { ATTRIBUTE(NUMBER_OF_USERS), @@ -2471,11 +1546,7 @@ void test_attribute_creation_happy_case() void test_attribute_creation_no_version() { - zwave_cc_version_t version = 0; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(0); std::vector created_types = { ATTRIBUTE(NUMBER_OF_USERS), @@ -2499,107 +1570,74 @@ void test_post_interview_discovery() // Lambdas auto count_user_node = [](size_t expected_value) { auto user_id_node_count - = attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); TEST_ASSERT_EQUAL_MESSAGE(expected_value, user_id_node_count, "User ID node count mismatch"); }; // Test logic + attribute_store::attribute cpp_node_id_node(node_id_node); NodeStateNetworkStatus network_status = ZCL_NODE_STATE_NETWORK_STATUS_OFFLINE; auto network_status_node - = attribute_store_emplace(node_id_node, - DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS, - &network_status, - sizeof(network_status)); + = cpp_node_id_node.emplace_node(DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS, + network_status); count_user_node(0); // Interview state network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_INTERVIEWING; - attribute_store_set_reported(network_status_node, - &network_status, - sizeof(network_status)); - + network_status_node.set_reported(network_status); count_user_node(0); // Simulate one more endpoint and only add nif to one of them // Add NIF to our endpoint to tell that we support User Credential std::vector nif_value = {COMMAND_CLASS_USER_CREDENTIAL}; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE_ZWAVE_SECURE_NIF, - nif_value.data(), - nif_value.size()); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE_ZWAVE_SECURE_NIF, nif_value); // Add another endpoint without User Credential support zwave_endpoint_id_t endpoint_id_2 = endpoint_id + 12; - attribute_store_emplace(node_id_node, - ATTRIBUTE_ENDPOINT_ID, - &endpoint_id_2, - sizeof(endpoint_id_2)); + cpp_node_id_node.emplace_node(ATTRIBUTE_ENDPOINT_ID, endpoint_id_2); // Display current store log for debug purpose attribute_store_log(); // Set the network status to online network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; - attribute_store_set_reported(network_status_node, - &network_status, - sizeof(network_status)); + network_status_node.set_reported(network_status); // Now we check attribute store - auto user_id_node - = attribute_store_get_first_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); - user_credential_user_unique_id_t user_id = 0; - attribute_store_get_desired(user_id_node, &user_id, sizeof(user_id)); - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - user_id_node, - "User id node should exists"); - TEST_ASSERT_EQUAL_MESSAGE(0, user_id, "User ID desired value should be 0"); + auto user_id_node = helper_test_attribute_value( + ATTRIBUTE(USER_UNIQUE_ID), + static_cast(0), + cpp_endpoint_id_node, + DESIRED_ATTRIBUTE); count_user_node(1); // Simulate user found - user_id = 12; - attribute_store_set_reported(user_id_node, &user_id, sizeof(user_id)); + user_credential_user_unique_id_t user_id = 12; + user_id_node.set_reported(user_id); // Go back to Interview state network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_INTERVIEWING; - attribute_store_set_reported(network_status_node, - &network_status, - sizeof(network_status)); + network_status_node.set_reported(network_status); // Then back in Online Functional network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; - attribute_store_set_reported(network_status_node, - &network_status, - sizeof(network_status)); + network_status_node.set_reported(network_status); + // User should still be there count_user_node(1); // With right value - user_credential_user_unique_id_t reported_user_id = 0; - user_id_node - = attribute_store_get_first_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); - attribute_store_get_reported(user_id_node, - &reported_user_id, - sizeof(reported_user_id)); - TEST_ASSERT_EQUAL_MESSAGE(user_id, - reported_user_id, - "User ID reported value should be 12."); + helper_test_attribute_value(ATTRIBUTE(USER_UNIQUE_ID), user_id); } void test_user_credential_notification_empty_parameters() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -2633,13 +1671,9 @@ void test_user_credential_notification_empty_parameters() } void test_user_credential_add_credential_already_defined_cred_type_and_slot() -{ - // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); +{ + // Initialize the notification callback + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -2787,11 +1821,6 @@ void test_user_credential_add_credential_invalid_slot() void test_user_credential_user_add_modify_delete_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - // Those functions are exposed and checks user values, so we need to setup the capabilities uint16_t number_of_users = 12; user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; @@ -2846,41 +1875,38 @@ void test_user_credential_user_add_modify_delete_happy_case() user_credential_modifier_type_t user_modifier_type = 2; user_credential_modifier_node_id_t user_modifier_node_id = 1212; - auto user_report_frame - = helper_create_user_report_frame(0x00, // user added - 0, // Next user id - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout, - user_name_encoding, - user_name); - - // Endpoint send User Add notification - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to create user"); + helper_simulate_user_report_frame(0x00, // user added + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); // Check values auto test_attribute_store_values = [&]() { - std::map uint8_attribute_map - = {{ATTRIBUTE(USER_MODIFIER_TYPE), user_modifier_type}, - {ATTRIBUTE(USER_TYPE), user_type}, - {ATTRIBUTE(USER_ACTIVE_STATE), user_active_state}, - {ATTRIBUTE(CREDENTIAL_RULE), credential_rule}}; - helper_test_attribute_store_values(uint8_attribute_map, user_node); - - std::map uint16_attribute_map - = {{ATTRIBUTE(USER_MODIFIER_NODE_ID), user_modifier_node_id}, - {ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), expiring_timeout}}; - helper_test_attribute_store_values(uint16_attribute_map, user_node); - - helper_test_string_value({{ATTRIBUTE(USER_NAME), user_name}}, user_node); + helper_test_attribute_value(ATTRIBUTE(USER_MODIFIER_TYPE), + user_modifier_type, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_TYPE), user_type, user_node); + helper_test_attribute_value(ATTRIBUTE(USER_ACTIVE_STATE), + user_active_state, + user_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_RULE), + credential_rule, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_MODIFIER_NODE_ID), + user_modifier_node_id, + user_node); + helper_test_attribute_value(ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + expiring_timeout, + user_node); + + helper_test_attribute_value(ATTRIBUTE(USER_NAME), user_name, user_node); }; test_attribute_store_values(); @@ -2892,46 +1918,34 @@ void test_user_credential_user_add_modify_delete_happy_case() user_name_encoding = 2; user_name = "JACKIE CAMION TURBO PLUS"; - user_report_frame = helper_create_user_report_frame(0x01, // modify user - 0, // Next user id - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout, - user_name_encoding, - user_name); - - // Endpoint send User Add notification - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to modify user"); + helper_simulate_user_report_frame(0x01, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); // Create notification report frame user_modifier_type = 5; user_modifier_node_id = 12122; - user_report_frame = helper_create_user_report_frame(0x01, // modify user - 0, // Next user id - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout, - user_name_encoding, - user_name); + helper_simulate_user_report_frame(0x01, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to modify user"); // Check values test_attribute_store_values(); @@ -2942,22 +1956,17 @@ void test_user_credential_user_add_modify_delete_happy_case() status, "User delete should have returned SL_STATUS_OK"); - user_report_frame = helper_create_user_report_frame(0x02, // modify user - 0, // Next user id - user_modifier_type, - user_modifier_node_id, - user_id, - user_type, - user_active_state, - credential_rule, - expiring_timeout, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to delete user"); + helper_simulate_user_report_frame(0x02, // modify user + 0, // Next user id + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); } void test_user_credential_credential_notification_add_modify_delete_happy_case() @@ -3050,24 +2059,18 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() // Check values auto test_attribute_store_values = [&]() { - std::map uint8_attribute_map - = {{ATTRIBUTE(CREDENTIAL_TYPE), credential_type}}; - helper_test_attribute_store_values(uint8_attribute_map, user_id_node); - - std::map uint16_attribute_map - = {{ATTRIBUTE(CREDENTIAL_SLOT), credential_slot}}; - helper_test_attribute_store_values(uint16_attribute_map, - credential_type_node); - - uint8_attribute_map - = {{ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), credential_modifier_type}}; - helper_test_attribute_store_values(uint8_attribute_map, - credential_slot_node); - - uint16_attribute_map - = {{ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), credential_modifier_node_id}}; - helper_test_attribute_store_values(uint16_attribute_map, - credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + user_id_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + credential_type_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), + credential_modifier_type, + credential_slot_node); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), + credential_modifier_node_id, + credential_slot_node); }; test_attribute_store_values(); @@ -3112,11 +2115,7 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() void test_user_credential_user_add_capabilites_failure_cases() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -3195,12 +2194,7 @@ void test_user_credential_user_add_capabilites_failure_cases() void test_user_credential_user_add_capabilites_happy_cred_rule_cases() { - // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); uint16_t number_of_users = 1; uint8_t username_max_length = 1; @@ -3252,12 +2246,7 @@ void test_user_credential_user_add_capabilites_happy_cred_rule_cases() void test_user_credential_user_add_capabilites_happy_user_type_rule_cases() { - // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); uint16_t number_of_users = 1; uint8_t username_max_length = 1; @@ -3310,11 +2299,7 @@ void test_user_credential_user_add_capabilites_happy_user_type_rule_cases() void test_user_credential_user_modify_capabilites_failure_cases() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -3394,11 +2379,7 @@ void test_user_credential_user_modify_capabilites_failure_cases() void test_user_credential_credential_add_capabilites_failure_cases() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -3474,11 +2455,7 @@ void test_user_credential_credential_add_capabilites_failure_cases() void test_user_credential_credential_add_capabilites_happy_case() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -3532,11 +2509,7 @@ void test_user_credential_credential_add_capabilites_happy_case() void test_user_credential_credential_modify_capabilites_failure_cases() { // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -3596,91 +2569,7 @@ void test_user_credential_credential_modify_capabilites_failure_cases() "Should not be able to modify credential data : it's too long"); } -void test_user_credential_user_set_error_report_user_add_happy_case() -{ - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - user_credential_user_unique_id_t user_id = 12; - - // Simulate invalid user - auto invalid_user_node - = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - auto valid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - auto user_report_frame = helper_create_user_report_frame( - 0x05, // USER_ADD_REJECTED_LOCATION_OCCUPIED - 0, // Next user id - 1, - 2, - user_id, - 1, - 0, - 1, - 0, - 0, - "TAJINE AUX EPICES"); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to handle USER_ADD_REJECTED_LOCATION_OCCUPIED"); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), - "Invalid User node should not exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid User node should exist"); -} - -void test_user_credential_user_set_error_report_user_modify_happy_case() -{ - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - - user_credential_user_unique_id_t user_id = 12; - - // Simulate invalid user (desired) - auto invalid_user_node - = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - auto user_report_frame = helper_create_user_report_frame( - 0x06, // USER_MODIFY_REJECTED_LOCATION_EMPTY - 0, // Next user id - 1, - 2, - user_id, - 1, - 0, - 1, - 0, - 0, - "SAUCISSE FUMEE"); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to handle USER_MODIFY_REJECTED_LOCATION_EMPTY"); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_user_node), - "Invalid User node should not exist"); -} - +// TODO : to be refactored void test_user_credential_credential_set_error_report_cred_add_happy_case() { user_credential_user_unique_id_t user_id = 12; @@ -3721,6 +2610,7 @@ void test_user_credential_credential_set_error_report_cred_add_happy_case() "Valid Credential type node should exist"); } +// TODO : to be refactored void test_user_credential_credential_set_error_report_cred_modify_happy_case() { user_credential_user_unique_id_t user_id = 12; @@ -3782,6 +2672,7 @@ void test_user_credential_credential_set_error_report_cred_modify_happy_case() "Valid Credential type node should exist"); } +// TODO : to be refactored void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() { user_credential_user_unique_id_t user_id = 12; @@ -3823,26 +2714,17 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( // Now actually send the report std::vector cred_data = {1, 2, 3, 4}; - auto credential_report_frame - = helper_create_credential_report_frame(user_id, - credential_type, - credential_slot, - 1, - cred_data, - CREDENTIAL_REPORT_DNE, - 2, - 0, - 0); - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; // Do the report - TEST_ASSERT_EQUAL(SL_STATUS_OK, - handler.control_handler(&info, - credential_report_frame.data(), - credential_report_frame.size())); + helper_simulate_credential_report_frame(user_id, + credential_type, + credential_slot, + 1, + cred_data, + CREDENTIAL_REPORT_DNE, + 2, + 0, + 0); // Now it should not exists TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), @@ -3853,6 +2735,7 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( "Valid Credential type node should exist"); } +// TODO : to be refactored // Note : same as test_user_credential_credential_set_error_report_cred_duplicate_happy_case // but with CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES in the report void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() @@ -3896,26 +2779,15 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c // Now actually send the report std::vector cred_data = {1, 2, 3, 4}; - auto credential_report_frame - = helper_create_credential_report_frame(user_id, - credential_type, - credential_slot, - 1, - cred_data, - CREDENTIAL_REPORT_DNE, - 2, - 0, - 0); - - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - // Do the report - TEST_ASSERT_EQUAL(SL_STATUS_OK, - handler.control_handler(&info, - credential_report_frame.data(), - credential_report_frame.size())); + helper_simulate_credential_report_frame(user_id, + credential_type, + credential_slot, + 1, + cred_data, + CREDENTIAL_REPORT_DNE, + 2, + 0, + 0); // Now it should not exists TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), @@ -3928,21 +2800,11 @@ void test_user_credential_credential_set_error_report_cred_security_rule_happy_c void test_user_credential_remove_all_users_happy_case() { - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + helper_set_version(1); - std::vector user_ids = {12, 15, 19}; + std::vector user_ids = {0, 12, 15, 19}; for (auto user_id: user_ids) { - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - user_id); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); } auto status @@ -3954,47 +2816,36 @@ void test_user_credential_remove_all_users_happy_case() "Remove all users should have returned SL_STATUS_OK"); TEST_ASSERT_EQUAL_MESSAGE( - user_ids.size() - + 1, // +1 because the remove all users will add an extra user to invoke the user SET command - attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)), + user_ids.size(), + cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(), "All users should have NOT have been removed yet"); - // This will handle the deletion - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x25, // All User deleted - // No need to have arguments here - std::vector().data(), - 0); + // This should remove all users + helper_simulate_user_report_frame(0x02, // Delete user + 0, // Next user id + 0, // User Type + 0, // User Node ID + 0, // User ID + 0, // User Type + 0, // User Active State + 0, // Credential Rule + 0, // Expiring Timeout + 0, // User Name Encoding + ""); // User Name TEST_ASSERT_EQUAL_MESSAGE( - 1, // Should be one user left here with desired value of 0 - attribute_store_get_node_child_count_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)), - "All users should have been removed yet"); - - user_credential_user_unique_id_t user_id = 0; - auto user_node - = attribute_store_get_node_child_by_value(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - DESIRED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); + 1, // User with ID 0 that might contains credentials + cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(), + "Only user 0 should be left"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_node), - "Should be one user node with desired value of 0 to " - "perform user interview"); + helper_test_attribute_value(ATTRIBUTE(USER_UNIQUE_ID), + static_cast(0)); } +// TODO : to be refactored void test_user_credential_remove_all_credentials_happy_case() { - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); + helper_set_version(1); TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, "Notification callback should be defined"); @@ -4053,6 +2904,7 @@ void test_user_credential_remove_all_credentials_happy_case() "User 0 should not exists"); } +// TODO : to be refactored void test_user_credential_remove_all_credentials_of_user() { const zwave_cc_version_t version = 1; @@ -4092,9 +2944,12 @@ void test_user_credential_remove_all_credentials_of_user() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - auto exploded_user_to_delete = explode_uint16(user_to_delete); - std::vector notification_parameters - = {exploded_user_to_delete.msb, exploded_user_to_delete.lsb, 0, 0, 0}; + zwave_frame notification_parameters; + notification_parameters.add(user_to_delete); + for (size_t i = 0; i < 3; i++) { + notification_parameters.add(static_cast(0)); + } + // This will handle the deletion notification_callback(endpoint_id_node, NOTIFICATION_ACCESS_CONTROL, @@ -4110,10 +2965,7 @@ void test_user_credential_remove_all_credentials_of_user() attribute_store_get_reported(node.user_id_node, &reported_user_id, sizeof(reported_user_id)); - printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", - node.user_id_node, - node.credential_type_node, - node.credential_slot_node); + node.print(); if (reported_user_id == user_to_delete) { TEST_ASSERT_FALSE_MESSAGE( @@ -4145,6 +2997,7 @@ void test_user_credential_remove_all_credentials_of_user() "User 0 should not exists"); } +// TODO : to be refactored void test_user_credential_remove_all_credentials_of_user_by_type() { const zwave_cc_version_t version = 1; @@ -4193,12 +3046,12 @@ void test_user_credential_remove_all_credentials_of_user_by_type() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - auto exploded_user_to_delete = explode_uint16(user_to_delete); - std::vector notification_parameters = {exploded_user_to_delete.msb, - exploded_user_to_delete.lsb, - credential_type_to_delete, - 0, - 0}; + zwave_frame notification_parameters; + notification_parameters.add(user_to_delete); + notification_parameters.add(credential_type_to_delete); + for (size_t i = 0; i < 2; i++) { + notification_parameters.add(static_cast(0)); + } // This will handle the deletion notification_callback(endpoint_id_node, @@ -4213,10 +3066,8 @@ void test_user_credential_remove_all_credentials_of_user_by_type() for (auto &node_data: expected_nodes_data) { auto nodes = node_data.nodes; auto should_not_exist = node_data.should_not_exist; - printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", - nodes.user_id_node, - nodes.credential_type_node, - nodes.credential_slot_node); + + nodes.print(); if (should_not_exist) { TEST_ASSERT_FALSE_MESSAGE( @@ -4248,6 +3099,7 @@ void test_user_credential_remove_all_credentials_of_user_by_type() "User 0 should not exists"); } +// TODO : to be refactored void test_user_credential_remove_all_credentials_by_type() { const zwave_cc_version_t version = 1; @@ -4312,10 +3164,8 @@ void test_user_credential_remove_all_credentials_by_type() for (auto &node_data: expected_nodes_data) { auto nodes = node_data.nodes; auto should_not_exist = node_data.should_not_exist; - printf("User node %d / Credential Type Node %d / Credential Slot Node %d\n", - nodes.user_id_node, - nodes.credential_type_node, - nodes.credential_slot_node); + + nodes.print(); if (should_not_exist) { TEST_ASSERT_FALSE_MESSAGE( @@ -4354,10 +3204,8 @@ void test_user_credential_credential_learn_start_add_happy_case() user_credential_slot_t credential_slot = 1; user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities uint8_t supported_credential_checksum = 1; @@ -4391,23 +3239,17 @@ void test_user_credential_credential_learn_start_add_happy_case() status, "Should be able to start learning"); - attribute_store_node_t credential_type_node; - attribute_store_node_t credential_slot_node; + attribute_store::attribute credential_type_node; + attribute_store::attribute credential_slot_node; auto update_credential_nodes = [&]() { credential_type_node - = attribute_store_get_node_child_by_value(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - DESIRED_ATTRIBUTE, - (uint8_t *)&credential_type, - sizeof(credential_type), - 0); + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + DESIRED_ATTRIBUTE); + credential_slot_node - = attribute_store_get_node_child_by_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - REPORTED_ATTRIBUTE, - (uint8_t *)&credential_slot, - sizeof(credential_slot), - 0); + = credential_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); }; update_credential_nodes(); @@ -4447,10 +3289,7 @@ void test_user_credential_credential_learn_start_add_cl_not_supported() user_credential_slot_t credential_slot = 1; user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities uint8_t supported_credential_checksum = 1; @@ -4490,10 +3329,7 @@ void test_user_credential_credential_learn_start_add_slot_not_supported() user_credential_slot_t credential_slot = 6; user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities uint8_t supported_credential_checksum = 1; @@ -4533,10 +3369,7 @@ void test_user_credential_credential_learn_start_add_type_not_supported() user_credential_slot_t credential_slot = 1; user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities uint8_t supported_credential_checksum = 1; @@ -4576,24 +3409,15 @@ void test_user_credential_credential_learn_start_add_credential_already_exists() user_credential_slot_t credential_slot = 1; user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - user_id = 15; - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - auto credential_type_node - = attribute_store_emplace(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - attribute_store_emplace(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Simulate already existing credential + user_id = 15; + helper_create_credential_structure(user_id, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + // Set capabilities uint8_t supported_credential_checksum = 1; std::vector supported_credential_type @@ -4753,10 +3577,7 @@ void test_user_credential_credential_learn_start_modify_credential_not_existing( user_credential_learn_timeout_t cl_timeout = 0; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities uint8_t supported_credential_checksum = 1; @@ -4793,25 +3614,14 @@ void test_user_credential_credential_learn_cancel_happy_case() { uint8_t stop_flag = 0; auto stop_node - = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(CREDENTIAL_LEARN_STOP), - &stop_flag, - sizeof(stop_flag)); - - auto &get_func = resolver_functions[CREDENTIAL_LEARN_CANCEL]; + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_STOP), + stop_flag, + DESIRED_ATTRIBUTE); - // Ask for a Get Command, should always be the same - TEST_ASSERT_NOT_NULL_MESSAGE( - get_func, - "Couldn't find get function in resolver_functions."); - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - get_func(stop_node, received_frame, &received_frame_size), - "Get function should have returned OK"); + helper_test_get_set_frame_happy_case(CREDENTIAL_LEARN_CANCEL, stop_node); - attribute_store_get_reported(stop_node, &stop_flag, sizeof(stop_flag)); TEST_ASSERT_EQUAL_MESSAGE(1, - stop_flag, + stop_node.reported(), "Stop flag should have been set to 1"); } @@ -4853,10 +3663,8 @@ void test_user_credential_uuic_association_same_slot_different_user() REPORTED_ATTRIBUTE); auto destination_user_id_node - = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &destination_user_id, - sizeof(destination_user_id)); + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + destination_user_id); helper_fill_credential_data(source_nodes.credential_slot_node, credential_data, @@ -4866,78 +3674,63 @@ void test_user_credential_uuic_association_same_slot_different_user() destination_user_id, destination_credential_slot); // Simulate Set - helper_test_set_get_with_args( + zwave_frame set_frame; + set_frame.add(source_user_id); + set_frame.add(credential_type); + set_frame.add(source_credential_slot); + set_frame.add(destination_user_id); + set_frame.add(destination_credential_slot); + + helper_test_get_set_frame_happy_case( USER_CREDENTIAL_ASSOCIATION_SET, association_nodes.association_credential_slot_node, - {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, - {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, - {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + set_frame); // Then simulate report - helper_association_report_frame(source_user_id, - credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot, - association_status); + helper_simulate_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); // Test data structure - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(source_nodes.credential_type_node), - "Old credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE(source_nodes.credential_type_node.is_valid(), + "Old credential type node should still exist"); TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(source_nodes.credential_slot_node), + source_nodes.credential_slot_node.is_valid(), "Old credential slot node should have been removed"); // Association nodes doesn't have any reported value so they shouldn't exists anymore TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(association_nodes.association_user_id_node), + association_nodes.association_user_id_node.is_valid(), "Association user id node should have been removed"); TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists( - association_nodes.association_credential_slot_node), + association_nodes.association_credential_slot_node.is_valid(), "Association credential slot node should have been removed"); TEST_ASSERT_EQUAL_MESSAGE( 0, - attribute_store_get_node_child_count(source_nodes.credential_type_node), + source_nodes.credential_type_node.child_count(), "Source Credential type node should have no children"); // Check destination structure auto destination_credential_type_node - = attribute_store_get_first_child_by_type(destination_user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - user_credential_type_t reported_credential_type; - attribute_store_get_reported(destination_credential_type_node, - &reported_credential_type, - sizeof(reported_credential_type)); - TEST_ASSERT_EQUAL_MESSAGE(credential_type, - reported_credential_type, - "Credential type mismatch"); + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + destination_user_id_node); auto destination_credential_slot_node - = attribute_store_get_first_child_by_type(destination_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - user_credential_slot_t reported_credential_slot; - attribute_store_get_reported(destination_credential_slot_node, - &reported_credential_slot, - sizeof(reported_credential_slot)); - TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, - reported_credential_slot, - "Credential slot mismatch"); + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), + destination_credential_slot, + destination_credential_type_node); helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); - uint8_t reported_status; - attribute_store_get_child_reported(destination_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &reported_status, - sizeof(reported_status)); - TEST_ASSERT_EQUAL_MESSAGE(association_status, - reported_status, - "Association status mismatch"); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); } void test_user_credential_uuic_association_different_slot_different_user_with_existing_type() @@ -4978,15 +3771,11 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex REPORTED_ATTRIBUTE); auto destination_user_id_node - = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &destination_user_id, - sizeof(destination_user_id)); + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + destination_user_id); // Already present type - attribute_store_emplace(destination_user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); + destination_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); helper_fill_credential_data(source_nodes.credential_slot_node, credential_data, @@ -4995,79 +3784,65 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex = helper_setup_association(source_nodes.credential_slot_node, destination_user_id, destination_credential_slot); + // Simulate Set - helper_test_set_get_with_args( + zwave_frame set_frame; + set_frame.add(source_user_id); + set_frame.add(credential_type); + set_frame.add(source_credential_slot); + set_frame.add(destination_user_id); + set_frame.add(destination_credential_slot); + + helper_test_get_set_frame_happy_case( USER_CREDENTIAL_ASSOCIATION_SET, association_nodes.association_credential_slot_node, - {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, - {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, - {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + set_frame); // Then simulate report - helper_association_report_frame(source_user_id, - credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot, - association_status); + helper_simulate_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); // Test data structure - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(source_nodes.credential_type_node), - "Old credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE(source_nodes.credential_type_node.is_valid(), + "Old credential type node should still exist"); TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(source_nodes.credential_slot_node), + source_nodes.credential_slot_node.is_valid(), "Old credential slot node should have been removed"); // Association nodes doesn't have any reported value so they shouldn't exists anymore TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(association_nodes.association_user_id_node), + association_nodes.association_user_id_node.is_valid(), "Association user id node should have been removed"); TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists( - association_nodes.association_credential_slot_node), + association_nodes.association_credential_slot_node.is_valid(), "Association credential slot node should have been removed"); TEST_ASSERT_EQUAL_MESSAGE( 0, - attribute_store_get_node_child_count(source_nodes.credential_type_node), + source_nodes.credential_type_node.child_count(), "Source Credential type node should have no children"); // Check destination structure auto destination_credential_type_node - = attribute_store_get_first_child_by_type(destination_user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - user_credential_type_t reported_credential_type; - attribute_store_get_reported(destination_credential_type_node, - &reported_credential_type, - sizeof(reported_credential_type)); - TEST_ASSERT_EQUAL_MESSAGE(credential_type, - reported_credential_type, - "Credential type mismatch"); + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + destination_user_id_node); auto destination_credential_slot_node - = attribute_store_get_first_child_by_type(destination_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - user_credential_slot_t reported_credential_slot; - attribute_store_get_reported(destination_credential_slot_node, - &reported_credential_slot, - sizeof(reported_credential_slot)); - TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, - reported_credential_slot, - "Credential slot mismatch"); + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), + destination_credential_slot, + destination_credential_type_node); helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); - uint8_t reported_status; - attribute_store_get_child_reported(destination_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &reported_status, - sizeof(reported_status)); - TEST_ASSERT_EQUAL_MESSAGE(association_status, - reported_status, - "Association status mismatch"); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); } void test_user_credential_uuic_association_different_slot_same_user() @@ -5115,22 +3890,25 @@ void test_user_credential_uuic_association_different_slot_same_user() destination_user_id, destination_credential_slot); // Simulate Set - helper_test_set_get_with_args( + zwave_frame set_frame; + set_frame.add(source_user_id); + set_frame.add(credential_type); + set_frame.add(source_credential_slot); + set_frame.add(destination_user_id); + set_frame.add(destination_credential_slot); + + helper_test_get_set_frame_happy_case( USER_CREDENTIAL_ASSOCIATION_SET, association_nodes.association_credential_slot_node, - {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, - {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, - {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + set_frame); // Then simulate report - helper_association_report_frame(source_user_id, - credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot, - association_status); + helper_simulate_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); // Test data structure TEST_ASSERT_TRUE_MESSAGE( @@ -5154,37 +3932,23 @@ void test_user_credential_uuic_association_different_slot_same_user() "Source Credential type node should have one children"); // Check destination structure - auto destination_credential_type_node = source_nodes.credential_type_node; - user_credential_type_t reported_credential_type; - attribute_store_get_reported(destination_credential_type_node, - &reported_credential_type, - sizeof(reported_credential_type)); - TEST_ASSERT_EQUAL_MESSAGE(credential_type, - reported_credential_type, - "Credential type mismatch"); + auto destination_credential_type_node + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + source_nodes.user_id_node); auto destination_credential_slot_node - = attribute_store_get_first_child_by_type(destination_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - user_credential_slot_t reported_credential_slot; - attribute_store_get_reported(destination_credential_slot_node, - &reported_credential_slot, - sizeof(reported_credential_slot)); - TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, - reported_credential_slot, - "Credential slot mismatch"); + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), + destination_credential_slot, + destination_credential_type_node); helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); - uint8_t reported_status; - attribute_store_get_child_reported(destination_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &reported_status, - sizeof(reported_status)); - TEST_ASSERT_EQUAL_MESSAGE(association_status, - reported_status, - "Association status mismatch"); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); } void test_user_credential_uuic_association_error_code() @@ -5226,10 +3990,8 @@ void test_user_credential_uuic_association_error_code() REPORTED_ATTRIBUTE); auto destination_user_id_node - = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &destination_user_id, - sizeof(destination_user_id)); + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + destination_user_id); helper_fill_credential_data(source_nodes.credential_slot_node, credential_data, @@ -5239,22 +4001,25 @@ void test_user_credential_uuic_association_error_code() destination_user_id, destination_credential_slot); // Simulate Set - helper_test_set_get_with_args( + zwave_frame set_frame; + set_frame.add(source_user_id); + set_frame.add(credential_type); + set_frame.add(source_credential_slot); + set_frame.add(destination_user_id); + set_frame.add(destination_credential_slot); + + helper_test_get_set_frame_happy_case( USER_CREDENTIAL_ASSOCIATION_SET, association_nodes.association_credential_slot_node, - {{source_nodes.user_id_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_type_node, REPORTED_ATTRIBUTE}, - {source_nodes.credential_slot_node, REPORTED_ATTRIBUTE}, - {association_nodes.association_user_id_node, DESIRED_ATTRIBUTE}, - {association_nodes.association_credential_slot_node, DESIRED_ATTRIBUTE}}); + set_frame); // Then simulate report - helper_association_report_frame(source_user_id, - credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot, - association_status); + helper_simulate_association_report_frame(source_user_id, + credential_type, + source_credential_slot, + destination_user_id, + destination_credential_slot, + association_status); // Test data structure TEST_ASSERT_TRUE_MESSAGE( @@ -5285,34 +4050,21 @@ void test_user_credential_uuic_association_error_code() // Test source credential slot node auto destination_credential_slot_node = source_nodes.credential_slot_node; - user_credential_slot_t reported_credential_slot; - attribute_store_get_reported(destination_credential_slot_node, - &reported_credential_slot, - sizeof(reported_credential_slot)); - TEST_ASSERT_EQUAL_MESSAGE(destination_credential_slot, - reported_credential_slot, - "Credential slot mismatch"); + helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), + destination_credential_slot, + source_nodes.credential_type_node); helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); - uint8_t reported_status; - attribute_store_get_child_reported(destination_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &reported_status, - sizeof(reported_status)); - TEST_ASSERT_EQUAL_MESSAGE(association_status, - reported_status, - "Association status mismatch"); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); } void test_get_user_checksum_with_credentials_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; user_credential_user_type_t user_type = 0x04; user_credential_user_active_state_t user_active_state = 0x01; @@ -5321,31 +4073,27 @@ void test_get_user_checksum_with_credentials_happy_case() std::string user_name = "Matt"; // Creating user - auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - // Simulate get on user - helper_test_set_get_with_args(USER_GET, - user_id_node, - {{user_id_node, DESIRED_ATTRIBUTE}}); - - auto user_report_frame = helper_create_user_report_frame(0x04, - 0, - 0x02, // Z-Wave - 0, - user_id, - user_type, - user_active_state, - credential_rules, - 0, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to create user"); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + + // Simulate get/report on user + zwave_frame user_get_frame; + user_get_frame.add(user_id); + helper_test_get_set_frame_happy_case(USER_GET, user_id_node, user_get_frame); + + helper_simulate_user_report_frame(0x04, + 0, + 0x02, // Z-Wave + 0, + user_id, + user_type, + user_active_state, + credential_rules, + 0, + user_name_encoding, + user_name); // Credentials std::vector credential_types @@ -5374,7 +4122,7 @@ void test_get_user_checksum_with_credentials_happy_case() } for (size_t i = 0; i < credential_types.size(); i++) { - auto credential_frame = helper_create_credential_report_frame( + helper_simulate_credential_report_frame( user_id, credential_types[i], credential_slots[i], @@ -5384,43 +4132,30 @@ void test_get_user_checksum_with_credentials_happy_case() 0, (i + 1) == credential_types.size() ? 0 : credential_types[i + 1], (i + 1) == credential_types.size() ? 0 : credential_slots[i + 1]); - - TEST_ASSERT_EQUAL_MESSAGE( - SL_STATUS_OK, - handler.control_handler(&info, - credential_frame.data(), - credential_frame.size()), - "Credential report should have returned SL_STATUS_OK"); } // Get checksum - auto checksum_node - = attribute_store_add_node(ATTRIBUTE(USER_CHECKSUM), user_id_node); + auto checksum_node = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); - helper_test_set_get_with_args(USER_CHECKSUM_GET, - checksum_node, - {{user_id_node, REPORTED_ATTRIBUTE}}); + zwave_frame checksum_get_frame; + checksum_get_frame.add(user_id); + + helper_test_get_set_frame_happy_case(USER_CHECKSUM_GET, + checksum_node, + checksum_get_frame); user_credential_checksum_t expected_checksum = 0x9024; helper_simulate_user_checksum_report(user_id, expected_checksum); // Check if checksum is correct - user_credential_checksum_t reported_checksum; - attribute_store_get_reported(checksum_node, - &reported_checksum, - sizeof(reported_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_checksum, - "Checksum mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); } void test_get_user_checksum_without_credentials_happy_case() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; user_credential_user_type_t user_type = 0x04; user_credential_user_active_state_t user_active_state = 0x01; @@ -5429,60 +4164,50 @@ void test_get_user_checksum_without_credentials_happy_case() std::string user_name = "Lillie"; // Creating user - auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - // Simulate get on user - helper_test_set_get_with_args(USER_GET, - user_id_node, - {{user_id_node, DESIRED_ATTRIBUTE}}); - - auto user_report_frame = helper_create_user_report_frame(0x04, - 0, - 0x02, // Z-Wave - 0, - user_id, - user_type, - user_active_state, - credential_rules, - 0, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to create user"); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + + // Simulate get/report on user + zwave_frame user_get_frame; + user_get_frame.add(user_id); + helper_test_get_set_frame_happy_case(USER_GET, user_id_node, user_get_frame); + + helper_simulate_user_report_frame(0x04, + 0, + 0x02, // Z-Wave + 0, + user_id, + user_type, + user_active_state, + credential_rules, + 0, + user_name_encoding, + user_name); // Get checksum - auto checksum_node - = attribute_store_add_node(ATTRIBUTE(USER_CHECKSUM), user_id_node); + auto checksum_node = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); + + zwave_frame checksum_get_frame; + checksum_get_frame.add(user_id); - helper_test_set_get_with_args(USER_CHECKSUM_GET, - checksum_node, - {{user_id_node, REPORTED_ATTRIBUTE}}); + helper_test_get_set_frame_happy_case(USER_CHECKSUM_GET, + checksum_node, + checksum_get_frame); user_credential_checksum_t expected_checksum = 0xF900; helper_simulate_user_checksum_report(user_id, expected_checksum); // Check if checksum is correct - user_credential_checksum_t reported_checksum; - attribute_store_get_reported(checksum_node, - &reported_checksum, - sizeof(reported_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_checksum, - "Checksum mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); } void test_get_user_checksum_without_credentials_mismatch_checksum() { - zwave_controller_connection_info_t info = {}; - info.remote.node_id = node_id; - info.remote.endpoint_id = endpoint_id; - info.local.is_multicast = false; - user_credential_user_unique_id_t user_id = 12; user_credential_user_type_t user_type = 0x04; user_credential_user_active_state_t user_active_state = 0x01; @@ -5491,39 +4216,37 @@ void test_get_user_checksum_without_credentials_mismatch_checksum() std::string user_name = "Lillie"; // Creating user - auto user_id_node = attribute_store_emplace_desired(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - // Simulate get on user - helper_test_set_get_with_args(USER_GET, - user_id_node, - {{user_id_node, DESIRED_ATTRIBUTE}}); - - auto user_report_frame = helper_create_user_report_frame(0x04, - 0, - 0x02, // Z-Wave - 0, - user_id, - user_type, - user_active_state, - credential_rules, - 0, - user_name_encoding, - user_name); - TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, - handler.control_handler(&info, - user_report_frame.data(), - user_report_frame.size()), - "Should have managed to create user"); - + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + + // Simulate get/report on user + zwave_frame user_get_frame; + user_get_frame.add(user_id); + helper_test_get_set_frame_happy_case(USER_GET, user_id_node, user_get_frame); + + + helper_simulate_user_report_frame(0x04, + 0, + 0x02, // Z-Wave + 0, + user_id, + user_type, + user_active_state, + credential_rules, + 0, + user_name_encoding, + user_name); // Get checksum - auto checksum_node - = attribute_store_add_node(ATTRIBUTE(USER_CHECKSUM), user_id_node); + auto checksum_node = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); + + zwave_frame checksum_get_frame; + checksum_get_frame.add(user_id); - helper_test_set_get_with_args(USER_CHECKSUM_GET, - checksum_node, - {{user_id_node, REPORTED_ATTRIBUTE}}); + helper_test_get_set_frame_happy_case(USER_CHECKSUM_GET, + checksum_node, + checksum_get_frame); // Simulate checksum mismatch user_credential_checksum_t expected_checksum = 0xF900; @@ -5533,36 +4256,25 @@ void test_get_user_checksum_without_credentials_mismatch_checksum() SL_STATUS_FAIL); // Check if checksum is correct - user_credential_checksum_t reported_calculated_checksum; - user_credential_checksum_t reported_error_checksum; - - attribute_store_get_reported(checksum_node, - &reported_calculated_checksum, - sizeof(reported_calculated_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(error_expected_checksum, - reported_calculated_checksum, - "Calculated checksum mismatch"); - - auto error_checksum_node = attribute_store_get_first_child_by_type( - user_id_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR)); - attribute_store_get_reported(error_checksum_node, - &reported_error_checksum, - sizeof(reported_error_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_error_checksum, - "Error checksum mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + error_expected_checksum, + checksum_node.reported(), + "Calculated checksum mismatch"); + + auto error_checksum_node + = helper_test_attribute_value(ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + expected_checksum, + user_id_node); // Now simulate checksum match helper_simulate_user_checksum_report(user_id, expected_checksum); - attribute_store_get_reported(checksum_node, - &reported_calculated_checksum, - sizeof(reported_calculated_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_calculated_checksum, - "Checksum mismatch"); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(error_checksum_node), + + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Calculated checksum mismatch"); + + TEST_ASSERT_FALSE_MESSAGE(error_checksum_node.is_valid(), "Error node should have been removed"); } @@ -5581,53 +4293,45 @@ void test_get_credential_checksum_happy_case() // Create empty RFID_CODE user_credential_type_t rfid_type = ZCL_CRED_TYPE_RFID_CODE; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - &rfid_type, - sizeof(rfid_type)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + rfid_type); if (tested_credential_types.size() != expected_checksums.size()) { TEST_FAIL_MESSAGE("All vectors should be the same size"); } for (size_t i = 0; i < tested_credential_types.size(); i++) { - auto current_credential_type = tested_credential_types[i]; - auto current_credential_type_node = attribute_store_get_node_child_by_value( - endpoint_id_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - REPORTED_ATTRIBUTE, - ¤t_credential_type, - sizeof(current_credential_type), - 0); + auto current_credential_type = tested_credential_types[i]; + auto current_credential_type_node + = cpp_endpoint_id_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + current_credential_type); - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(current_credential_type_node), - "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(current_credential_type_node.is_valid(), + "Credential type node should exist"); // Get checksum auto checksum_node - = attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), - current_credential_type_node); + = current_credential_type_node.add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); - helper_test_set_get_with_args( - CREDENTIAL_CHECKSUM_GET, - checksum_node, - {{current_credential_type_node, REPORTED_ATTRIBUTE}}); + zwave_frame checksum_get_frame; + checksum_get_frame.add(current_credential_type); + + helper_test_get_set_frame_happy_case(CREDENTIAL_CHECKSUM_GET, + checksum_node, + checksum_get_frame); user_credential_checksum_t expected_checksum = expected_checksums[i]; helper_simulate_credential_checksum_report(current_credential_type, expected_checksum); // Check if checksum is correct - user_credential_checksum_t reported_checksum; - attribute_store_get_reported(checksum_node, - &reported_checksum, - sizeof(reported_checksum)); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_checksum, - (std::string("Checksum mismatch for type ") - + std::to_string(current_credential_type)) - .c_str()); + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + (std::string("Checksum mismatch for type ") + + std::to_string(current_credential_type)) + .c_str()); } } @@ -5645,28 +4349,25 @@ void test_get_credential_checksum_mismatch() } for (size_t i = 0; i < tested_credential_types.size(); i++) { - auto current_credential_type = tested_credential_types[i]; - auto current_credential_type_node = attribute_store_get_node_child_by_value( - endpoint_id_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - REPORTED_ATTRIBUTE, - ¤t_credential_type, - sizeof(current_credential_type), - 0); + auto current_credential_type = tested_credential_types[i]; + auto current_credential_type_node + = cpp_endpoint_id_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + current_credential_type); - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(current_credential_type_node), - "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(current_credential_type_node.is_valid(), + "Credential type node should exist"); // Get checksum auto checksum_node - = attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), - current_credential_type_node); + = current_credential_type_node.add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); - helper_test_set_get_with_args( - CREDENTIAL_CHECKSUM_GET, - checksum_node, - {{current_credential_type_node, REPORTED_ATTRIBUTE}}); + zwave_frame checksum_get_frame; + checksum_get_frame.add(current_credential_type); + + helper_test_get_set_frame_happy_case(CREDENTIAL_CHECKSUM_GET, + checksum_node, + checksum_get_frame); user_credential_checksum_t error_checksum = expected_checksums[i] + 1; helper_simulate_credential_checksum_report(current_credential_type, @@ -5674,28 +4375,15 @@ void test_get_credential_checksum_mismatch() SL_STATUS_FAIL); // Check error checksum - user_credential_checksum_t reported_mismatch_checksum; - user_credential_checksum_t reported_error_checksum; - - attribute_store_get_reported(checksum_node, - &reported_error_checksum, - sizeof(reported_error_checksum)); - - TEST_ASSERT_EQUAL_MESSAGE(error_checksum, - reported_error_checksum, - "Reported checksum mismatch"); - - auto mismatch_checksum_node = attribute_store_get_first_child_by_type( - current_credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR)); - - attribute_store_get_reported(mismatch_checksum_node, - &reported_mismatch_checksum, - sizeof(reported_mismatch_checksum)); + TEST_ASSERT_EQUAL_MESSAGE( + error_checksum, + checksum_node.reported(), + "Reported checksum mismatch"); - TEST_ASSERT_EQUAL_MESSAGE(expected_checksums[i], - reported_mismatch_checksum, - "Mismatch checksum mismatch"); + auto mismatch_checksum_node = helper_test_attribute_value( + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), + expected_checksums[i], + current_credential_type_node); // Try again with correct checksum @@ -5704,17 +4392,13 @@ void test_get_credential_checksum_mismatch() expected_checksum); // Check if checksum is correct - user_credential_checksum_t reported_checksum; - attribute_store_get_reported(checksum_node, - &reported_checksum, - sizeof(reported_checksum)); - - TEST_ASSERT_EQUAL_MESSAGE(expected_checksum, - reported_checksum, - "Checksum mismatch"); + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(mismatch_checksum_node), + mismatch_checksum_node.is_valid(), "Mismatch checksum node should have been removed"); } } From c3d38a10231ae95a875abbe4ff0b75687536fc70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 20 Aug 2024 15:18:58 +0200 Subject: [PATCH 27/60] UIC-3222: Remove explode_uint16() and get_string_value() Those functions are not needed anymore with the new C++ helpers. get_uint16_value will be removed when credential refactoring is here --- .../zwave_command_class_user_credential.cpp | 68 +++++-------------- 1 file changed, 17 insertions(+), 51 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 3bff12cde..0966cf52a 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -473,32 +473,6 @@ uint16_t get_uint16_value(const uint8_t *frame, uint16_t start_index) return extracted_value; } -// Transform a uint16_t into 2 uint8_t -uint16_exploded explode_uint16(uint16_t value) -{ - uint8_t msb = (value & 0xFF00) >> 8; - uint8_t lsb = (value & 0x00FF); - return uint16_exploded {msb, lsb}; -} - -std::string get_string_value(const uint8_t *frame_data, - uint16_t start_index, - uint8_t str_size) -{ - std::string value; - // Check if our name fits our buffer ; if not it is truncated - if (str_size > MAX_CHAR_SIZE) { - sl_log_warning(LOG_TAG, "Invalid char size"); - str_size = MAX_CHAR_SIZE; - } - - for (int i = 0; i < str_size; i++) { - value += frame_data[start_index + i]; - } - - return value; -} - /////////////////////////////////////////////////////////////////////// // Mics helpers /////////////////////////////////////////////////////////////////////// @@ -1053,9 +1027,8 @@ sl_status_t node_to_uint8_vector(attribute_store_node_t node, value_state, &uint16_value, sizeof(uint16_value)); - auto exploded_uint16 = explode_uint16(uint16_value); - data.push_back(exploded_uint16.msb); - data.push_back(exploded_uint16.lsb); + data.push_back((uint16_value & 0xFF00) >> 8); + data.push_back((uint16_value & 0x00FF)); } break; // Variable length field case BYTE_ARRAY_STORAGE_TYPE: { @@ -3624,44 +3597,37 @@ user_credential_checksum_t compute_checksum_and_verify_integrity( ///////////////////////////////////////////////////////////////////////////// // User Checksum Get/Report ///////////////////////////////////////////////////////////////////////////// - static sl_status_t zwave_command_class_user_credential_user_checksum_get( attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { sl_log_debug(LOG_TAG, "User Checksum Get"); + attribute_store::attribute checksum_node(node); - auto user_id_node - = attribute_store_get_first_parent_with_type(node, - ATTRIBUTE(USER_UNIQUE_ID)); + auto user_id_node = checksum_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - if (!attribute_store_node_exists(user_id_node)) { + if (!user_id_node.is_valid()) { sl_log_error( LOG_TAG, "Can't find User Unique ID node. Not sending User Checksum Get."); return SL_STATUS_NOT_SUPPORTED; } - user_credential_user_unique_id_t user_id = 0; - sl_status_t status - = attribute_store_get_reported(user_id_node, &user_id, sizeof(user_id)); + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_CHECKSUM_GET_FRAME)); - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't get user unique id value. Not sending User Checksum Get."); + try { + frame_generator.initialize_frame(USER_CHECKSUM_GET, + frame, + expected_frame_size); + frame_generator.add_value(user_id_node); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User Checksum Get frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - auto exploded_value = explode_uint16(user_id); - - ZW_USER_CHECKSUM_GET_FRAME *get_frame = (ZW_USER_CHECKSUM_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = USER_CHECKSUM_GET; - get_frame->userUniqueIdentifier1 = exploded_value.msb; - get_frame->userUniqueIdentifier2 = exploded_value.lsb; - - *frame_length = sizeof(ZW_USER_CHECKSUM_GET_FRAME); - return SL_STATUS_OK; } From 994383f2c3b74684a241275ba885053cadb47f77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 20 Aug 2024 15:34:52 +0200 Subject: [PATCH 28/60] UIC-3222: Replace create_command_frame by frame_generator Also rename get_credential_identifier_nodes --- .../zwave_command_class_user_credential.cpp | 223 +++++------------- 1 file changed, 56 insertions(+), 167 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 0966cf52a..03eec4b7f 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -122,18 +122,20 @@ struct attribute_command_data { attribute_store_node_t node = ATTRIBUTE_STORE_INVALID_NODE; }; -struct credential_nodes { +struct credential_id_nodes { attribute_store::attribute slot_node; attribute_store::attribute type_node; attribute_store::attribute user_unique_id_node; }; /** - * @brief - * @param node - * @return + * @brief Get associated credential identifier nodes + * + * @param node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents + + * @return credential_id_nodes Credential identifier nodes */ -credential_nodes get_credential_nodes(attribute_store_node_t node) +credential_id_nodes get_credential_identifier_nodes(attribute_store_node_t node) { attribute_store::attribute slot_node(node); slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); @@ -1119,64 +1121,6 @@ bool add_node_to_checksum(std::vector ¤t_checksum, return true; }; -/** - * @brief Create a command frame (SET or GET) based on the attribute store - * - * @param command Command to send (will be in frame[1], e.g USER_SET) - * @param command_data Attributes that will be in the frame (in order of appearance in the frame) - * @param base_node If not specified otherwise will fetch the attributes that are under this node - * @param frame Frame object from the callback - * @param frame_length Frame size from the callback - * - * @return sl_status_t SL_STATUS_OK if everything was fine - */ -sl_status_t - create_command_frame(uint8_t command, - std::vector command_data, - attribute_store_node_t base_node, - uint8_t *frame, - uint16_t *frame_length) -{ - frame[0] = COMMAND_CLASS_USER_CREDENTIAL; - frame[1] = command; - - uint16_t current_index = 2; - - for (auto &attribute_info: command_data) { - auto attribute_description - = attribute_store_get_type_name(attribute_info.attribute_type); - - attribute_store_node_t node; - if (attribute_info.node == ATTRIBUTE_STORE_INVALID_NODE) { - node = attribute_store_get_first_child_by_type( - base_node, - attribute_info.attribute_type); - } else { - node = attribute_info.node; - } - - if (node == ATTRIBUTE_STORE_INVALID_NODE) { - sl_log_critical(LOG_TAG, - "Can't find node for Attribute %s", - attribute_description); - return SL_STATUS_FAIL; - } - - std::vector data; - sl_status_t status - = node_to_uint8_vector(node, data, attribute_info.attribute_state); - if (status != SL_STATUS_OK) { - return status; - } - for (auto &byte: data) { - frame[current_index++] = byte; - } - } - - *frame_length = current_index; - - return SL_STATUS_OK; -} /** * @brief Updates the desired values of attributes in the attribute store. @@ -2104,8 +2048,8 @@ sl_status_t zwave_command_class_user_credential_credential_set( { sl_log_debug(LOG_TAG, "Credential Set"); try { - credential_nodes cred_nodes - = get_credential_nodes(credential_operation_type_node); + auto cred_nodes + = get_credential_identifier_nodes(credential_operation_type_node); auto operation_type = cred_nodes.slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_OPERATION_TYPE)) @@ -2169,7 +2113,7 @@ static sl_status_t zwave_command_class_user_credential_credential_get( { sl_log_debug(LOG_TAG, "Credential Get"); - credential_nodes cred_nodes = get_credential_nodes(credential_slot_node); + auto cred_nodes = get_credential_identifier_nodes(credential_slot_node); // Generate the frame constexpr auto expected_frame_size @@ -2559,79 +2503,31 @@ sl_status_t // Credential Learn Start/Report/Stop ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_credential_learn_start( - attribute_store_node_t credential_operation_type_node, - uint8_t *frame, - uint16_t *frame_length) + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - // Identifiers nodes - attribute_store_node_t credential_slot_node - = attribute_store_get_first_parent_with_type(credential_operation_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - attribute_store_node_t credential_type_node - = attribute_store_get_first_parent_with_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - attribute_store_node_t user_unique_id_node - = attribute_store_get_first_parent_with_type(credential_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); - - // Get operation type - user_credential_operation_type_t operation_type = 0; - sl_status_t status - = attribute_store_get_desired(credential_operation_type_node, - &operation_type, - sizeof(operation_type)); - - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't get operation type. Not sending Credential Learn Start."); - return SL_STATUS_NOT_SUPPORTED; - } - - auto credential_learn_timeout_node = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)); + sl_log_debug(LOG_TAG, "Credential Learn Start"); + attribute_store::attribute credential_operation_type_node(node); - sl_log_debug( - LOG_TAG, - "Credential Learn Start for Credential Slot %d, Credential Type %d, " - "User %d (operation type : %d, timeout : %d)", - static_cast( - attribute_store_get_reported_number(credential_slot_node)), - static_cast( - attribute_store_get_reported_number(credential_type_node)), - static_cast( - attribute_store_get_reported_number(user_unique_id_node)), - operation_type, - static_cast( - attribute_store_get_reported_number(credential_learn_timeout_node))); - - // Since the data is not linear we provide the node directly - std::vector set_data - = {{ATTRIBUTE(USER_UNIQUE_ID), - DESIRED_OR_REPORTED_ATTRIBUTE, - user_unique_id_node}, - {ATTRIBUTE(CREDENTIAL_TYPE), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_type_node}, - {ATTRIBUTE(CREDENTIAL_SLOT), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_slot_node}, - {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - DESIRED_ATTRIBUTE, - credential_operation_type_node}, - {ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), - DESIRED_OR_REPORTED_ATTRIBUTE, - credential_learn_timeout_node}}; - - status = create_command_frame(CREDENTIAL_LEARN_START, - set_data, - credential_slot_node, - frame, - frame_length); + try { + frame_generator.initialize_frame(CREDENTIAL_LEARN_START, + frame, + sizeof(ZW_CREDENTIAL_LEARN_START_FRAME)); + auto nodes = get_credential_identifier_nodes(credential_operation_type_node); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Can't create Credential Learn Start"); + frame_generator.add_value(nodes.user_unique_id_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(nodes.type_node, DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(nodes.slot_node, DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(credential_operation_type_node, + DESIRED_ATTRIBUTE); + frame_generator.add_value( + nodes.slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating Credential Learn Start frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } @@ -2865,46 +2761,39 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_uuic_association_set( - attribute_store_node_t destination_credential_slot_node, + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - // Get nodes - auto credential_slot_node = attribute_store_get_first_parent_with_type( - destination_credential_slot_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - auto credential_type_node - = attribute_store_get_first_parent_with_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - auto user_id_node - = attribute_store_get_first_parent_with_type(credential_type_node, - ATTRIBUTE(USER_UNIQUE_ID)); - sl_log_debug(LOG_TAG, "User Unique Identifier Credential Association Set command"); + attribute_store::attribute destination_credential_slot_node(node); - // Set the frame - // Since the data is not linear we provide the node directly - std::vector set_data - = {{ATTRIBUTE(USER_UNIQUE_ID), REPORTED_ATTRIBUTE, user_id_node}, - {ATTRIBUTE(CREDENTIAL_TYPE), REPORTED_ATTRIBUTE, credential_type_node}, - {ATTRIBUTE(CREDENTIAL_SLOT), REPORTED_ATTRIBUTE, credential_slot_node}, - {ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), DESIRED_ATTRIBUTE}, - {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), DESIRED_ATTRIBUTE}}; - - sl_status_t status = create_command_frame(USER_CREDENTIAL_ASSOCIATION_SET, - set_data, - credential_slot_node, - frame, - frame_length); + try { + frame_generator.initialize_frame( + USER_CREDENTIAL_ASSOCIATION_SET, + frame, + sizeof(ZW_USER_CREDENTIAL_ASSOCIATION_SET_FRAME)); - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't create User Unique Identifier Credential Association Set frame"); + auto nodes = get_credential_identifier_nodes(destination_credential_slot_node); + frame_generator.add_value(nodes.user_unique_id_node, + REPORTED_ATTRIBUTE); + frame_generator.add_value(nodes.type_node, REPORTED_ATTRIBUTE); + frame_generator.add_value(nodes.slot_node, REPORTED_ATTRIBUTE); + frame_generator.add_value(nodes.slot_node.child_by_type(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)), + DESIRED_ATTRIBUTE); + frame_generator.add_value(destination_credential_slot_node, + DESIRED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User Unique Identifier Credential " + "Association Set frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - return status; + return SL_STATUS_OK; } sl_status_t zwave_command_class_user_credential_uuic_association_report( From 2cf48b00ccc13dc3ac10380fc2611122c6846276 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 20 Aug 2024 17:03:13 +0200 Subject: [PATCH 29/60] UIC-3222: Refactor Credential Learn --- .../zwave_command_class_user_credential.cpp | 449 +++++++++--------- 1 file changed, 220 insertions(+), 229 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 03eec4b7f..1d68322ae 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -128,27 +128,6 @@ struct credential_id_nodes { attribute_store::attribute user_unique_id_node; }; -/** - * @brief Get associated credential identifier nodes - * - * @param node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents - - * @return credential_id_nodes Credential identifier nodes - */ -credential_id_nodes get_credential_identifier_nodes(attribute_store_node_t node) -{ - attribute_store::attribute slot_node(node); - slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); - attribute_store::attribute type_node - = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); - attribute_store::attribute user_unique_id_node - = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - return {.slot_node = slot_node, - .type_node = type_node, - .user_unique_id_node = user_unique_id_node}; -} - ///////////////////////////////////////////////////////////////////////////// // Capabilites Data Structs ///////////////////////////////////////////////////////////////////////////// @@ -930,6 +909,102 @@ attribute_store_node_t return credential_type_node; } + +/** + * @brief Get associated credential identifier nodes + * + * @param node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents + * + * @throws std::runtime_error If one of the nodes is not found + * + * @return credential_id_nodes Credential identifier nodes + */ +credential_id_nodes get_credential_identifier_nodes(attribute_store_node_t node) +{ + attribute_store::attribute slot_node(node); + slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store::attribute type_node + = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); + attribute_store::attribute user_unique_id_node + = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + if (!slot_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential slot node."); + } + + if (!type_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential type node."); + } + + if (!user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID node."); + } + + return {.slot_node = slot_node, + .type_node = type_node, + .user_unique_id_node = user_unique_id_node}; +} + +template struct identifier_state { + T value; + attribute_store_node_value_state_t state; +}; +/** + * @brief Get associated credential identifier nodes + * + * @param endpoint_node Endpoint node + * @param user_id User ID with given state + * @param credential_type Credential type with given state + * @param credential_slot Credential slot with given state + * + * @return credential_id_nodes Credential identifier nodes + */ +credential_id_nodes get_credential_identifier_nodes( + const attribute_store::attribute &endpoint_node, + identifier_state user_id, + identifier_state credential_type, + identifier_state credential_slot) +{ + credential_id_nodes nodes; + + nodes.user_unique_id_node + = get_user_unique_id_node(endpoint_node, user_id.value, user_id.state); + + if (!nodes.user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID " + + std::to_string(user_id.value)); + } + + nodes.type_node = get_credential_type_node(nodes.user_unique_id_node, + credential_type.value, + credential_type.state); + + if (!nodes.type_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "type %1% for user %2%") + % credential_type.value % user_id.value) + .str()); + } + + nodes.slot_node = get_credential_slot_node(nodes.type_node, + credential_slot.value, + credential_slot.state); + + if (!nodes.slot_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "slot %1% for credential type %2% / user %3%") + % credential_slot.value % credential_type.value % user_id.value) + .str()); + } + return nodes; +} + ///////////////////////////////////////////////////////////////////////////// // Attributes helpers ///////////////////////////////////////////////////////////////////////////// @@ -1025,7 +1100,7 @@ sl_status_t node_to_uint8_vector(attribute_store_node_t node, } break; case U16_STORAGE_TYPE: { uint16_t uint16_value; - status = attribute_store_read_value(node, + status = attribute_store_read_value(node, value_state, &uint16_value, sizeof(uint16_value)); @@ -2113,12 +2188,12 @@ static sl_status_t zwave_command_class_user_credential_credential_get( { sl_log_debug(LOG_TAG, "Credential Get"); - auto cred_nodes = get_credential_identifier_nodes(credential_slot_node); - // Generate the frame constexpr auto expected_frame_size = static_cast(sizeof(ZW_CREDENTIAL_GET_FRAME)); try { + auto cred_nodes = get_credential_identifier_nodes(credential_slot_node); + frame_generator.initialize_frame(CREDENTIAL_GET, frame, expected_frame_size); @@ -2512,7 +2587,8 @@ static sl_status_t zwave_command_class_user_credential_credential_learn_start( frame_generator.initialize_frame(CREDENTIAL_LEARN_START, frame, sizeof(ZW_CREDENTIAL_LEARN_START_FRAME)); - auto nodes = get_credential_identifier_nodes(credential_operation_type_node); + auto nodes + = get_credential_identifier_nodes(credential_operation_type_node); frame_generator.add_value(nodes.user_unique_id_node, DESIRED_OR_REPORTED_ATTRIBUTE); @@ -2535,22 +2611,17 @@ static sl_status_t zwave_command_class_user_credential_credential_learn_start( } static sl_status_t zwave_command_class_user_credential_credential_learn_cancel( - attribute_store_node_t credential_learn_stop_node, - uint8_t *frame, - uint16_t *frame_length) + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - uint8_t stop_flag = 1; - attribute_store_set_reported(credential_learn_stop_node, - &stop_flag, - sizeof(stop_flag)); - attribute_store_undefine_desired(credential_learn_stop_node); + sl_log_debug(LOG_TAG, "Credential Learn Cancel"); + attribute_store::attribute credential_learn_stop_node(node); - frame[0] = COMMAND_CLASS_USER_CREDENTIAL; - frame[1] = CREDENTIAL_LEARN_CANCEL; + credential_learn_stop_node.set_reported(1); + credential_learn_stop_node.clear_desired(); - *frame_length = 2; - - return SL_STATUS_OK; + return frame_generator.generate_no_args_frame(CREDENTIAL_LEARN_CANCEL, + frame, + frame_length); } sl_status_t zwave_command_class_user_credential_credential_learn_status_report( @@ -2558,202 +2629,122 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t EXPECTED_FRAME_LENGTH = 9; - if (frame_length != EXPECTED_FRAME_LENGTH) { - sl_log_error(LOG_TAG, - "CREDENTIAL_LEARN_STATUS_REPORT frame length is not valid. " - "Expected %d, got %d", - EXPECTED_FRAME_LENGTH, - frame_length); - return SL_STATUS_NOT_SUPPORTED; - } + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); - constexpr uint8_t INDEX_LEARN_STATUS = 2; - constexpr uint8_t INDEX_USER_ID = 3; - constexpr uint8_t INDEX_CREDENTIAL_TYPE = 5; - constexpr uint8_t INDEX_CREDENTIAL_SLOT = 6; - constexpr uint8_t INDEX_CREDENTIAL_LEARN_STEP_REMAINING = 8; + try { + zwave_frame_parser parser(frame_data, frame_length); - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + if (!parser.is_frame_size_valid(sizeof(ZW_CREDENTIAL_LEARN_REPORT_FRAME))) { + sl_log_error( + LOG_TAG, + "Invalid frame size for Credential Learn Status Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } - // Interpret frame - const uint8_t learn_status = frame_data[INDEX_LEARN_STATUS]; - const user_credential_user_unique_id_t user_id - = get_uint16_value(frame_data, INDEX_USER_ID); - const user_credential_type_t credential_type - = frame_data[INDEX_CREDENTIAL_TYPE]; - const user_credential_slot_t credential_slot - = get_uint16_value(frame_data, INDEX_CREDENTIAL_SLOT); - const uint8_t step_remaining - = frame_data[INDEX_CREDENTIAL_LEARN_STEP_REMAINING]; + // Parse the frame + const uint8_t learn_status = parser.read_byte(); + const auto user_id + = parser.read_sequential(2); + const user_credential_type_t credential_type = parser.read_byte(); + const auto credential_slot + = parser.read_sequential(2); + const uint8_t step_remaining = parser.read_byte(); - sl_log_debug(LOG_TAG, - "Credential Learn Status Report. Credential Type: %d / " - "Credential Slot: %d (User %d)", - credential_type, - credential_slot, - user_id); + sl_log_debug(LOG_TAG, + "Credential Learn Status Report. Credential Type: %d / " + "Credential Slot: %d (User %d)", + credential_type, + credential_slot, + user_id); - // Get the nodes - attribute_store_node_t credential_type_node; - attribute_store_node_t credential_slot_node; + auto credential_id_nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, DESIRED_OR_REPORTED_ATTRIBUTE}, + {credential_slot, DESIRED_OR_REPORTED_ATTRIBUTE}); - get_credential_type_node(endpoint_node, - user_id, - credential_type, - DESIRED_ATTRIBUTE, - credential_type_node); - if (!attribute_store_node_exists(credential_type_node)) { - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - } - get_credential_slot_node(credential_type_node, - credential_slot, - DESIRED_ATTRIBUTE, - credential_slot_node); - if (!attribute_store_node_exists(credential_slot_node)) { - get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - } + // Get operation type so we can handle error cases + auto operation_type + = credential_id_nodes.slot_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)) + .desired(); - if (!attribute_store_node_exists(credential_slot_node) - || !attribute_store_node_exists(credential_type_node)) { - sl_log_error(LOG_TAG, - "Can't find User %d, Credential Type %d, " - "Credential Slot %d reported by Credential Learn Status", - user_id, - credential_type, - credential_slot); - return SL_STATUS_NOT_SUPPORTED; - } + // Action based of current learn status + std::string learn_status_str; + bool need_deletion = false; + sl_log_level_t log_level = SL_LOG_INFO; - // Get operation type so we can handle error cases - auto credential_learn_operation_type_node - = attribute_store_get_first_child_by_type( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)); + switch (learn_status) { + case CREDENTIAL_LEARN_REPORT_STARTED: + learn_status_str = "Credential Learn Started"; + break; + case CREDENTIAL_LEARN_REPORT_SUCCESS: + learn_status_str = "Credential Learn Success"; + break; + case CREDENTIAL_LEARN_REPORT_ALREADY_IN_PROGRESS: + log_level = SL_LOG_WARNING; + learn_status_str = "Credential Learn already in progress"; + break; + case CREDENTIAL_LEARN_REPORT_ENDED_NOT_DUE_TO_TIMEOUT: + learn_status_str = "Credential Learn ended not due to timeout"; + need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); + break; + case CREDENTIAL_LEARN_REPORT_TIMEOUT: + log_level = SL_LOG_WARNING; + learn_status_str = "Credential Learn Timeout"; + need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); + break; + case 0x05: // Credential Learn Step Retry + learn_status_str = "Credential Learn Step Needs a Retry"; + need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); + break; + case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_ADD_OPERATION_TYPE: + log_level = SL_LOG_ERROR; + learn_status_str = "Invalid Add Operation Types"; + break; + case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_MODIFY_OPERATION_TYPE: + log_level = SL_LOG_ERROR; + learn_status_str = "Invalid Modify Operation Type"; + need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); + break; + default: + learn_status_str + = "Unknown Credential Learn Status " + std::to_string(learn_status); + log_level = SL_LOG_CRITICAL; + } - user_credential_operation_type_t operation_type = 0; - sl_status_t status - = attribute_store_get_desired(credential_learn_operation_type_node, - &operation_type, - sizeof(operation_type)); + sl_log(LOG_TAG, + log_level, + "%s for User %d, Credential Type %d, " + "Credential Slot %d", + learn_status_str.c_str(), + user_id, + credential_type, + credential_slot); + + if (need_deletion) { + credential_id_nodes.slot_node.delete_node(); + } - if (status != SL_STATUS_OK) { + // Update nodes + credential_id_nodes.slot_node.emplace_node( + ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), + step_remaining); + credential_id_nodes.slot_node.emplace_node( + ATTRIBUTE(CREDENTIAL_LEARN_STATUS), + learn_status); + + } catch (const std::exception &e) { sl_log_error( LOG_TAG, - "Can't get learn operation type. Ignoring Credential Learn Report."); - return SL_STATUS_NOT_SUPPORTED; - } + "Error while parsing Credential Learn Status Report frame : %s", + e.what()); - // Action based of current learn status - switch (learn_status) { - case CREDENTIAL_LEARN_REPORT_STARTED: - sl_log_info(LOG_TAG, - "Credential Learn Started for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - break; - case CREDENTIAL_LEARN_REPORT_SUCCESS: - sl_log_info(LOG_TAG, - "Credential Learn Success for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - break; - case CREDENTIAL_LEARN_REPORT_ALREADY_IN_PROGRESS: - sl_log_warning( - LOG_TAG, - "Credential Learn already in progress for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - break; - case CREDENTIAL_LEARN_REPORT_ENDED_NOT_DUE_TO_TIMEOUT: - sl_log_info(LOG_TAG, - "Credential Learn ended not due to timeout for User %d, " - "Credential Type %d, Credential Slot %d", - user_id, - credential_type, - credential_slot); - // Handle error case for add, remove the current slot - if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { - attribute_store_delete_node(credential_slot_node); - } - break; - case CREDENTIAL_LEARN_REPORT_TIMEOUT: - sl_log_warning( - LOG_TAG, - "Credential Learn Timeout for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - // Handle error case for add, remove the current slot - if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { - attribute_store_delete_node(credential_slot_node); - } - break; - case 0x05: // Credential Learn Step Retry - sl_log_info( - LOG_TAG, - "Credential Learn Step Needs a Retry for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - // Handle error case for add, remove the current slot - if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { - attribute_store_delete_node(credential_slot_node); - } - break; - case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_ADD_OPERATION_TYPE: - sl_log_error( - LOG_TAG, - "Invalid Add Operation Type for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - break; - case CREDENTIAL_LEARN_REPORT_INVALID_CREDENTIAL_LEARN_MODIFY_OPERATION_TYPE: - sl_log_error( - LOG_TAG, - "Invalid Modify Operation Type for User %d, Credential Type %d, " - "Credential Slot %d", - user_id, - credential_type, - credential_slot); - // Handle error case for add, remove the current slot - if (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD) { - attribute_store_delete_node(credential_slot_node); - } - break; + return SL_STATUS_NOT_SUPPORTED; } - // Update attribute store - status = attribute_store_set_child_reported( - credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_STEPS_REMAINING), - &step_remaining, - sizeof(step_remaining)); - - status - |= attribute_store_set_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_STATUS), - &learn_status, - sizeof(learn_status)); - return status; + return SL_STATUS_OK; } ///////////////////////////////////////////////////////////////////////////// @@ -2761,9 +2752,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_uuic_association_set( - attribute_store_node_t node, - uint8_t *frame, - uint16_t *frame_length) + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { sl_log_debug(LOG_TAG, "User Unique Identifier Credential Association Set command"); @@ -2775,13 +2764,14 @@ static sl_status_t zwave_command_class_user_credential_uuic_association_set( frame, sizeof(ZW_USER_CREDENTIAL_ASSOCIATION_SET_FRAME)); - auto nodes = get_credential_identifier_nodes(destination_credential_slot_node); - frame_generator.add_value(nodes.user_unique_id_node, - REPORTED_ATTRIBUTE); + auto nodes + = get_credential_identifier_nodes(destination_credential_slot_node); + frame_generator.add_value(nodes.user_unique_id_node, REPORTED_ATTRIBUTE); frame_generator.add_value(nodes.type_node, REPORTED_ATTRIBUTE); frame_generator.add_value(nodes.slot_node, REPORTED_ATTRIBUTE); - frame_generator.add_value(nodes.slot_node.child_by_type(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)), - DESIRED_ATTRIBUTE); + frame_generator.add_value( + nodes.slot_node.child_by_type(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)), + DESIRED_ATTRIBUTE); frame_generator.add_value(destination_credential_slot_node, DESIRED_ATTRIBUTE); frame_generator.validate_frame(frame_length); @@ -3235,7 +3225,7 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( attribute_store_delete_node(user_node); } - + return SL_STATUS_OK; } else { sl_log_error(LOG_TAG, @@ -3304,7 +3294,8 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( return SL_STATUS_OK; case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: sl_log_warning(LOG_TAG, - "User %d was not modified/added since the expiring timeout minutes is invalid.", + "User %d was not modified/added since the expiring " + "timeout minutes is invalid.", current_user_id); return SL_STATUS_OK; default: From d634ddc055e34e4ae88d91e1cad8d996d32c8269 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 29 Aug 2024 10:56:22 +0200 Subject: [PATCH 30/60] UIC-3222: New Specification of Credential Report Remove all Notification callbacks --- .../zwave_command_class_user_credential.cpp | 1473 ++++++----------- ...ave_command_class_user_credential_test.cpp | 866 +++------- 2 files changed, 705 insertions(+), 1634 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 1d68322ae..4b14075f8 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -19,7 +19,6 @@ #include "zwave_command_classes_utils.h" #include "ZW_classcmd.h" -#include "zwave_command_class_notification.h" // Includes from other ZPC Components #include "zwave_command_class_indices.h" @@ -66,6 +65,10 @@ constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; constexpr uint8_t MAX_CHAR_SIZE = 64; // Used to compute checksums constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; + +// Using +using attribute_callback = std::function; + /** * @brief Implementation notes * @@ -470,6 +473,39 @@ std::u16string utf8_to_utf16(const std::string &utf8) // Command Class Helper ///////////////////////////////////////////////////////////////////////////// +/** + * @brief Update desired value if found, or create the node otherwise + * + * Check for the value in the desired value of attribute_type (with parent base_node). + * If we found it, we update the reported value and clear the desired value. + * Otherwise we create the node with the given value and set it to reported. + * + * @tparam T Type of the value to set + * + * @param base_node Base node to search for the attribute + * @param attribute_type Type of the attribute to search for + * @param value Value to search/set + * + * @return attribute_store::attribute Node that was created/updated + */ +template attribute_store::attribute + create_or_update_desired_value(attribute_store::attribute base_node, + attribute_store_type_t attribute_type, + T value) +{ + auto node = base_node.child_by_type_and_value(attribute_type, + value, + DESIRED_ATTRIBUTE); + if (!node.is_valid()) { + node = base_node.emplace_node(attribute_type, value); + } else { + node.set_reported(value); + node.clear_desired(); + } + + return node; +} + void set_operation_type(attribute_store_node_t node, attribute_store_type_t operation_type_node_type, user_credential_operation_type_t operation_type) @@ -747,6 +783,8 @@ bool get_credential_type_node(attribute_store_node_t endpoint_node, * By default it will return all the credential type nodes, but you can narrow * to a specific credential type with the credential_type parameter * + * @deprecated Use for_each_credential_type_nodes instead + * * @param endpoint_node Endpoint point node * @param credential_type Credential type to find. If 0, will return all credential types * @@ -802,6 +840,52 @@ std::vector return credential_type_nodes; } + +/** + * @brief Iterate on each credential type nodes for a given user + * + * @param user_id_node User ID node + * @param callback Callback function to call for each credential type node + * @param credential_type Credential type to find. If 0, process all credential types + */ +void for_each_credential_type_nodes_for_user( + attribute_store::attribute user_id_node, + const attribute_callback &callback, + user_credential_type_t credential_type = 0) +{ + auto credential_type_nodes = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); + for (auto &credential_type_node: credential_type_nodes) { + // Call + if (credential_type == 0 + || (credential_type_node.reported_exists() + && credential_type_node.reported() + == credential_type)) { + callback(credential_type_node); + } + } +} + +/** + * @brief Iterate on each credential type nodes + * + * @param endpoint_node Endpoint point node + * @param callback Callback function to call for each credential type node + * @param credential_type Credential type to find. If 0, process all credential types + */ +void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, + const attribute_callback &callback, + user_credential_type_t credential_type = 0) +{ + auto user_nodes = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)); + for (auto &user_node: user_nodes) { + for_each_credential_type_nodes_for_user(user_node, + callback, + credential_type); + } +} + + + /** * @brief Get credential slot node * @@ -913,15 +997,16 @@ attribute_store_node_t /** * @brief Get associated credential identifier nodes * - * @param node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents + * @param child_node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents * * @throws std::runtime_error If one of the nodes is not found * * @return credential_id_nodes Credential identifier nodes */ -credential_id_nodes get_credential_identifier_nodes(attribute_store_node_t node) +credential_id_nodes + get_credential_identifier_nodes(attribute_store_node_t child_node) { - attribute_store::attribute slot_node(node); + attribute_store::attribute slot_node(child_node); slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); attribute_store::attribute type_node = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); @@ -960,6 +1045,8 @@ template struct identifier_state { * @param credential_type Credential type with given state * @param credential_slot Credential slot with given state * + * @throws std::runtime_error If one of the nodes is not found + * * @return credential_id_nodes Credential identifier nodes */ credential_id_nodes get_credential_identifier_nodes( @@ -1249,525 +1336,6 @@ sl_status_t update_desired_values( return status; } -///////////////////////////////////////////////////////////////////////////// -// Notification callback -///////////////////////////////////////////////////////////////////////////// - -namespace notification_handler -{ -namespace credential -{ -// Indexes -// Credential Notification Report Frame -constexpr uint8_t INDEX_USER_UNIQUE_ID = 0; -constexpr uint8_t INDEX_CREDENTIAL_TYPE = 2; -constexpr uint8_t INDEX_CREDENTIAL_SLOT = 3; -constexpr uint8_t INDEX_CREDENTIAL_CRB = 5; -constexpr uint8_t INDEX_CREDENTIAL_LENGTH = 6; -constexpr uint8_t INDEX_CREDENTIAL_DATA = 7; -constexpr uint8_t CREDENTIAL_NOTIFICATION_REPORT_MIN_FRAME_LENGTH - = INDEX_CREDENTIAL_DATA + 3; - -user_credential_type_t get_credential_type(const uint8_t *event_parameters) -{ - return event_parameters[INDEX_CREDENTIAL_TYPE]; -} - -user_credential_slot_t get_credential_slot(const uint8_t *event_parameters) -{ - return get_uint16_value(event_parameters, INDEX_CREDENTIAL_SLOT); -} -user_credential_user_unique_id_t get_user_id(const uint8_t *event_parameters) -{ - return get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); -} -user_credential_modifier_type_t - get_credential_modifier_type(const uint8_t *event_parameters) -{ - // TODO : Update this with the new specification where CREDENTIAL_DATA doesn't exists anymore - return event_parameters[8]; -} - -attribute_store_node_t - get_credential_type_node(attribute_store_node_t endpoint_node, - const uint8_t *event_parameters, - attribute_store_node_value_state_t state) -{ - user_credential_user_unique_id_t user_id - = get_uint16_value(event_parameters, INDEX_USER_UNIQUE_ID); - user_credential_type_t credential_type - = get_credential_type(event_parameters); - - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - bool credential_type_node_found - = get_credential_type_node(endpoint_node, - user_id, - credential_type, - state, - credential_type_node); - if (!credential_type_node_found) { - sl_log_debug( - LOG_TAG, - "Can't find credential type %d present in Notification Parameters", - credential_type); - } - - return credential_type_node; -} - -attribute_store_node_t - get_credential_slot_node(attribute_store_node_t credential_type_node, - const uint8_t *event_parameters, - attribute_store_node_value_state_t state) -{ - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - - user_credential_slot_t credential_slot - = get_credential_slot(event_parameters); - - bool credential_slot_node_found - = get_credential_slot_node(credential_type_node, - credential_slot, - state, - credential_slot_node); - if (!credential_slot_node_found) { - sl_log_debug( - LOG_TAG, - "Can't find credential slot %d present in Notification Parameters", - credential_slot); - } - return credential_slot_node; -} - -bool is_report_size_conform(uint8_t event_parameters_length) -{ - if (event_parameters_length - < CREDENTIAL_NOTIFICATION_REPORT_MIN_FRAME_LENGTH) { - sl_log_error(LOG_TAG, "Invalid Credential Notification Report size"); - return false; - } - - return true; -}; - -// Only have the first 3 parameters (user id, credential type, credential slot) -// Permissive to some noise in the frame after the data we care about -bool is_credential_deletion_size_conform(uint8_t event_parameters_length) -{ - if (event_parameters_length < 5) { - sl_log_error(LOG_TAG, "Invalid Credential Event Multiple Deletion size"); - return false; - } - - return true; -}; - -void update_credential_reported_values( - attribute_store_node_t credential_slot_node, const uint8_t *event_parameters) -{ - const uint8_t credential_length = event_parameters[INDEX_CREDENTIAL_LENGTH]; - const uint8_t INDEX_CREDENTIAL_MODIFIER_TYPE - = INDEX_CREDENTIAL_DATA + credential_length; - const uint8_t INDEX_CREDENTIAL_MODIFIER_NODE_ID - = INDEX_CREDENTIAL_MODIFIER_TYPE + 1; - - // Set standard (uint8 & uint16) data - std::vector user_data = { - {ATTRIBUTE(CREDENTIAL_READ_BACK), - INDEX_CREDENTIAL_CRB, - CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, - 7}, - {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), INDEX_CREDENTIAL_MODIFIER_TYPE}, - {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), INDEX_CREDENTIAL_MODIFIER_NODE_ID}, - }; - - sl_status_t status = set_reported_attributes(credential_slot_node, - event_parameters, - user_data); - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Error while setting reported attributes"); - return; - } - - auto credential_data_node - = attribute_store_get_first_child_by_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA)); - - status - = attribute_store_set_reported(credential_data_node, - &event_parameters[INDEX_CREDENTIAL_DATA], - credential_length); - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Can't set CREDENTIAL_DATA in attribute store"); - return; - } - attribute_store_undefine_desired(credential_data_node); -}; - -} // namespace credential -} // namespace notification_handler - -void on_notification_event(attribute_store_node_t endpoint_node, - uint8_t notification_type, - uint8_t event_code, - const uint8_t *event_parameters, - uint8_t event_parameters_length) -{ - // We don't care about anything else than access control - if (notification_type != NOTIFICATION_ACCESS_CONTROL) { - return; - } - - auto get_credential_slot_node_by_type = [&]() { - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type(event_parameters); - user_credential_slot_t credential_slot - = notification_handler::credential::get_credential_slot(event_parameters); - user_credential_user_unique_id_t user_id - = notification_handler::credential::get_user_id(event_parameters); - - // Credential type node - attribute_store_node_t credential_type_node - = notification_handler::credential::get_credential_type_node( - endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_error(LOG_TAG, - "Didn't find credential type %d (user %d).", - credential_type, - user_id); - return ATTRIBUTE_STORE_INVALID_NODE; - } - - attribute_store_node_t credential_slot_node - = notification_handler::credential::get_credential_slot_node( - credential_type_node, - event_parameters, - REPORTED_ATTRIBUTE); - - if (!attribute_store_node_exists(credential_slot_node)) { - sl_log_error(LOG_TAG, - "Didn't find credential slot %d for credential type %d " - "(user %d).", - credential_slot, - credential_type, - user_id); - return ATTRIBUTE_STORE_INVALID_NODE; - } - - return credential_slot_node; - }; - - // Logic - switch (event_code) { - // Credential Added - case 0x2B: { - sl_log_debug(LOG_TAG, "Notification : Credential Added"); - - if (!notification_handler::credential::is_report_size_conform( - event_parameters_length)) { - return; - } - - // Type and slot - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type( - event_parameters); - user_credential_slot_t credential_slot - = notification_handler::credential::get_credential_slot( - event_parameters); - - // Credential type node - attribute_store_node_t credential_type_node - = notification_handler::credential::get_credential_type_node( - endpoint_node, - event_parameters, - DESIRED_ATTRIBUTE); - - // Credential Type might be already present here - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_debug( - LOG_TAG, - "Didn't find credential type %d with desired value, checking " - "reported value.", - credential_type); - credential_type_node - = notification_handler::credential::get_credential_type_node( - endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - // Now this is a real issue, we doesn't update anything - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_error(LOG_TAG, - "Didn't find credential type %d. Can't add credential.", - credential_type); - return; - } - } else { - // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason - attribute_store_undefine_desired(credential_type_node); - // If we found the credential we mark it a reported now. - attribute_store_set_reported(credential_type_node, - &credential_type, - sizeof(credential_type)); - } - - // Now we'll check the credential slot - attribute_store_node_t credential_slot_node - = notification_handler::credential::get_credential_slot_node( - credential_type_node, - event_parameters, - DESIRED_ATTRIBUTE); - // This must be in defined state - if (!attribute_store_node_exists(credential_slot_node)) { - sl_log_error(LOG_TAG, - "Didn't find credential slot %d with desired value. Not " - "adding credential", - credential_slot); - return; - } - - // Do not use attribute_store_set_reported_as_desired here since it will introduce wired behavior for some reason - attribute_store_undefine_desired(credential_slot_node); - // If we found the credential we mark it a reported now. - attribute_store_set_reported(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); - - notification_handler::credential::update_credential_reported_values( - credential_slot_node, - event_parameters); - - } break; - // Credential Modified - case 0x2C: { - sl_log_debug(LOG_TAG, "Notification : Credential Modified"); - if (!notification_handler::credential::is_report_size_conform( - event_parameters_length)) { - return; - } - - // Used in logs - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type( - event_parameters); - user_credential_slot_t credential_slot - = notification_handler::credential::get_credential_slot( - event_parameters); - user_credential_user_unique_id_t user_id - = notification_handler::credential::get_user_id(event_parameters); - - // Get credential slot - auto credential_slot_node = get_credential_slot_node_by_type(); - if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { - return; - } - - notification_handler::credential::update_credential_reported_values( - credential_slot_node, - event_parameters); - - sl_log_debug(LOG_TAG, - "Credential Modified. Type %d, Slot %d (User %d) ", - credential_type, - credential_slot, - user_id); - } break; - // Credential Deleted - case 0x2D: { - sl_log_debug(LOG_TAG, "Notification : Credential Deleted"); - if (!notification_handler::credential::is_report_size_conform( - event_parameters_length)) { - return; - } - - // Used in logs - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type( - event_parameters); - user_credential_slot_t credential_slot - = notification_handler::credential::get_credential_slot( - event_parameters); - user_credential_user_unique_id_t user_id - = notification_handler::credential::get_user_id(event_parameters); - - // Type and slot - auto credential_slot_node = get_credential_slot_node_by_type(); - if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { - return; - } - attribute_store_delete_node(credential_slot_node); - sl_log_debug(LOG_TAG, - "Credential Deleted. Type %d, Slot %d (User %d) ", - credential_type, - credential_slot, - user_id); - } break; - // Credential unchanged - case 0x2E: { - sl_log_debug(LOG_TAG, "Notification : Credential Unchanged"); - if (!notification_handler::credential::is_report_size_conform( - event_parameters_length)) { - return; - } - - // Used in logs - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type( - event_parameters); - user_credential_slot_t credential_slot - = notification_handler::credential::get_credential_slot( - event_parameters); - user_credential_user_unique_id_t user_id - = notification_handler::credential::get_user_id(event_parameters); - - // Type and slot - auto credential_slot_node = get_credential_slot_node_by_type(); - if (credential_slot_node == ATTRIBUTE_STORE_INVALID_NODE) { - return; - } - - // If user doesn't exists in the device we try to remove it also from our side - user_credential_modifier_type_t modifier_type - = notification_handler::credential::get_credential_modifier_type( - event_parameters); - if (modifier_type == CREDENTIAL_REPORT_DNE) { - attribute_store_delete_node(credential_slot_node); - } else { - sl_log_info(LOG_TAG, - "Credential Unchanged, clearing desired values. For Type " - "%d, Slot %d (User %d)", - credential_type, - credential_slot, - user_id); - - attribute_store_undefine_desired(credential_slot_node); - attribute_store_undefine_desired( - attribute_store_get_node_child_by_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - 0)); - } - } break; - // All user deleted - case 0x25: { - sl_log_debug(LOG_TAG, "Notification : All User Deleted"); - - // Delete all user nodes - auto user_node_count = attribute_store_get_node_child_count_by_type( - endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID)); - - for (size_t i = 0; i < user_node_count; i++) { - attribute_store_node_t user_node - = attribute_store_get_node_child_by_type( - endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - 0); // 0 not i here since user will be deleted - attribute_store_delete_node(user_node); - } - sl_log_info(LOG_TAG, "All credentials deleted."); - - sl_log_debug(LOG_TAG, - "Interview users again to make sure they are not any left."); - trigger_get_user(endpoint_node, 0); - } break; - // Multiple credential deleted - case 0x26: { - sl_log_debug(LOG_TAG, "Notification : Multiple credential deleted"); - - if (!notification_handler::credential:: - is_credential_deletion_size_conform(event_parameters_length)) { - return; - } - - user_credential_user_unique_id_t user_id - = notification_handler::credential::get_user_id(event_parameters); - user_credential_type_t credential_type - = notification_handler::credential::get_credential_type( - event_parameters); - - if (user_id != 0 && credential_type != 0) { - // Delete all slots for an credential type associated with user - sl_log_debug(LOG_TAG, - "Delete all slots for credential type %d and user %d", - credential_type, - user_id); - - auto cred_type_node - = notification_handler::credential::get_credential_type_node( - endpoint_node, - event_parameters, - REPORTED_ATTRIBUTE); - - if (!attribute_store_node_exists(cred_type_node)) { - sl_log_error(LOG_TAG, - "Didn't find credential type %d associated with user " - "%d. Can't delete credentials.", - credential_type, - user_id); - return; - } - - attribute_store_delete_node(cred_type_node); - - sl_log_info(LOG_TAG, - "All credentials of type %d for user %d deleted.", - credential_type, - user_id); - } else if (user_id != 0) { - // Delete all credentials for a user - auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "Didn't find user ID %d. Can't delete credentials.", - user_id); - return; - } - // Delete all credential type nodes associated with this user - auto user_node_count = attribute_store_get_node_child_count_by_type( - user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - - for (size_t i = 0; i < user_node_count; i++) { - attribute_store_node_t credential_type_node - = attribute_store_get_node_child_by_type( - user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - 0); // 0 not i here since user will be deleted - attribute_store_delete_node(credential_type_node); - } - sl_log_info(LOG_TAG, "All credentials for user %d deleted.", user_id); - } else if (credential_type != 0) { - // Delete all credentials of a type - auto credential_type_nodes - = get_all_credential_type_nodes(endpoint_node, credential_type); - for (auto credential_type_node: credential_type_nodes) { - attribute_store_delete_node(credential_type_node); - } - sl_log_info(LOG_TAG, "Credential of type %d deleted", credential_type); - } else { - // Delete all credentials - auto credential_type_nodes - = get_all_credential_type_nodes(endpoint_node); - for (auto credential_type_node: credential_type_nodes) { - attribute_store_delete_node(credential_type_node); - } - sl_log_info(LOG_TAG, "All credentials deleted.", user_id); - } - - // Check if we still have a user 0 in the datastore, and remove it since it should not be here - auto user_0_node = get_reported_user_id_node(endpoint_node, 0); - attribute_store_delete_node(user_0_node); - } break; - default: - break; - } -} - ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -1803,9 +1371,9 @@ static void zwave_command_class_user_credential_on_version_attribute_update( COUNT_OF(attributes)); // Listen to - zwave_command_class_notification_register_event_callback( - endpoint_node, - &on_notification_event); + // zwave_command_class_notification_register_event_callback( + // endpoint_node, + // &on_notification_event); } ///////////////////////////////////////////////////////////////////////////// @@ -2058,13 +1626,7 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( /** * @brief Trigger a GET credential command * - * Create credential_type if it doesn't exists - * - * If credential_slot exists : - * - Set desired value as reported - * - Clear reported value - * Otherwise : - * - Set desired value + * Create credential_type (reported) and credential_slot (desired) nodes if they don't exist * * trigger_get_credential(user_node, 0, 0) will trigger a GET command for the first credential of user_node * @@ -2073,47 +1635,24 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( * @param credential_slot 0 to get the first credential; valid value otherwise * */ -void trigger_get_credential(attribute_store_node_t user_unique_id_node, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) +void trigger_get_credential( + attribute_store::attribute &user_unique_id_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) { sl_log_debug(LOG_TAG, "Trigger GET credential for user %d : " "Credential type %d, credential slot %d", - static_cast( - attribute_store_get_reported_number(user_unique_id_node)), + user_unique_id_node.reported(), credential_type, credential_slot); - - // Create credential type node if it doesn't exists - // Since the GET is mapped to the Credential SLOT we doesn't need to do anything specific here - attribute_store_node_t credential_type_node - = attribute_store_emplace(user_unique_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - - // Then check if credential slot node exists - attribute_store_node_t credential_slot_node - = attribute_store_get_node_child_by_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - REPORTED_ATTRIBUTE, - (uint8_t *)&credential_slot, - sizeof(credential_slot), - 0); - - // If it exists we clear it reported value and set it as desired - if (attribute_store_node_exists(credential_slot_node)) { - attribute_store_set_desired(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); - attribute_store_undefine_reported(credential_slot_node); - } else { // If non existant we create it - attribute_store_emplace_desired(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - } + user_unique_id_node + .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + REPORTED_ATTRIBUTE) + .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); } sl_status_t zwave_command_class_user_credential_credential_set( @@ -2202,6 +1741,13 @@ static sl_status_t zwave_command_class_user_credential_credential_get( frame_generator.add_value(cred_nodes.type_node, REPORTED_ATTRIBUTE); frame_generator.add_value(cred_nodes.slot_node, DESIRED_ATTRIBUTE); frame_generator.validate_frame(frame_length); + + // Delete special nodes (start interview of credentials) + if (cred_nodes.type_node.reported() == 0 + && cred_nodes.slot_node.desired() == 0) { + cred_nodes.type_node.delete_node(); + cred_nodes.slot_node.delete_node(); + } } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while generating Credential Get frame : %s", @@ -2212,363 +1758,331 @@ static sl_status_t zwave_command_class_user_credential_credential_get( return SL_STATUS_OK; } -sl_status_t zwave_command_class_user_credential_credential_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) +enum class credential_report_type_t : uint8_t { + CREDENTIAL_ADDED = 0x00, + CREDENTIAL_MODIFIED = 0x01, + CREDENTIAL_DELETED = 0x02, + CREDENTIAL_UNCHANGED = 0x03, + RESPONSE_TO_GET = 0x04, + CREDENTIAL_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, + CREDENTIAL_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, + CREDENTIAL_DUPLICATE_ERROR = 0x07, + CREDENTIAL_MANUFACTURER_SECURITY_RULE = 0x08, + CREDENTIAL_LOCATION_ALREADY_ASSIGNED = 0x09, + CREDENTIAL_DUPLICATE_ADMIN_CODE = 0x0A +}; + +sl_status_t + handle_credential_deletion(attribute_store::attribute &endpoint_node, + attribute_store::attribute &user_id_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_user_unique_id_t credential_slot) { - // Since INDEX_CREDENTIAL_DATA is a variable length field we know that we at lest expect 16 elements - if (frame_length < 15) { - return SL_STATUS_NOT_SUPPORTED; + if (user_id != 0 && credential_type != 0 && credential_slot != 0) { + sl_log_info(LOG_TAG, + "Credential Deleted. Type %d, Slot %d (User %d)", + credential_type, + credential_slot, + user_id); + // Delete the credential slot node + get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}) + .slot_node.delete_node(); + } else if (user_id != 0 && credential_type != 0 && credential_slot == 0) { + sl_log_info(LOG_TAG, + "All credential type %d deleted for user %d.", + credential_type, + user_id); + for_each_credential_type_nodes_for_user( + user_id_node, + [&](attribute_store::attribute &credential_type_node) { + credential_type_node.delete_node(); + }, + credential_type); + } else if (user_id != 0 && credential_type == 0 && credential_slot == 0) { + sl_log_info(LOG_TAG, "All credentials for user %d deleted.", user_id); + for_each_credential_type_nodes_for_user( + user_id_node, + [&](attribute_store::attribute &credential_type_node) { + credential_type_node.delete_node(); + }); + } else if (user_id == 0 && credential_type == 0 && credential_slot == 0) { + sl_log_info(LOG_TAG, "All credentials deleted."); + for_each_credential_type_nodes( + endpoint_node, + [&](attribute_store::attribute &credential_type_node) { + credential_type_node.delete_node(); + }); + } else if (user_id == 0 && credential_type != 0 && credential_slot == 0) { + sl_log_info(LOG_TAG, + "All credentials of type %d are deleted", + credential_type); + for_each_credential_type_nodes( + endpoint_node, + [&](attribute_store::attribute &credential_type_node) { + credential_type_node.delete_node(); + }, + credential_type); + } else { + sl_log_critical(LOG_TAG, + "Invalid combination of user_id %d, credential_type %d and " + "credential_slot %d for credential deletion", + user_id, + credential_type, + credential_slot); + return SL_STATUS_FAIL; } - constexpr uint8_t INDEX_USER_ID = 2; - constexpr uint8_t INDEX_CREDENTIAL_TYPE = 4; - constexpr uint8_t INDEX_CREDENTIAL_SLOT = 5; - constexpr uint8_t INDEX_CREDENTIAL_READ_BACK = 7; - constexpr uint8_t INDEX_CREDENTIAL_LENGTH = 8; - constexpr uint8_t INDEX_CREDENTIAL_DATA = 9; - const uint8_t credential_length = frame_data[INDEX_CREDENTIAL_LENGTH]; - const uint8_t INDEX_CREDENTIAL_MODIFIER_TYPE - = INDEX_CREDENTIAL_DATA + credential_length; - const uint8_t INDEX_CREDENTIAL_MODIFIER_NODE_ID - = INDEX_CREDENTIAL_MODIFIER_TYPE + 1; - const uint8_t INDEX_NEXT_CREDENTIAL_TYPE - = INDEX_CREDENTIAL_MODIFIER_NODE_ID + 2; - const uint8_t INDEX_NEXT_CREDENTIAL_SLOT = INDEX_NEXT_CREDENTIAL_TYPE + 1; - - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); - - const user_credential_user_unique_id_t user_id - = get_uint16_value(frame_data, INDEX_USER_ID); - const user_credential_type_t credential_type - = frame_data[INDEX_CREDENTIAL_TYPE]; - const user_credential_slot_t credential_slot - = get_uint16_value(frame_data, INDEX_CREDENTIAL_SLOT); + return SL_STATUS_OK; +} - auto remove_credential_type_and_slot_0_if_exists = [&]() { - attribute_store_node_t type_node_0; - attribute_store_node_t slot_node_0; - // Get nodes 0 - get_credential_type_node(endpoint_node, - user_id, - 0, - REPORTED_ATTRIBUTE, - type_node_0); - get_credential_slot_node(type_node_0, 0, DESIRED_ATTRIBUTE, slot_node_0); - - // Remove them - attribute_store_delete_node(type_node_0); - attribute_store_delete_node(slot_node_0); - }; - - if (credential_type == 0 || credential_slot == 0) { - sl_log_debug(LOG_TAG, "User %d has no credential to get", user_id); - remove_credential_type_and_slot_0_if_exists(); - sl_log_debug(LOG_TAG, "Removed credential type and slot 0"); - return SL_STATUS_OK; - } +sl_status_t zwave_command_class_user_credential_credential_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Report"); - sl_log_debug( - LOG_TAG, - "Credential Report. Credential Type: %d / Credential Slot: %d (User %d)", - credential_type, - credential_slot, - user_id); + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - // We should have a valid user id if we receive this report - attribute_store_node_t user_unique_id_node - = get_reported_user_id_node(endpoint_node, user_id); + const uint8_t min_size = 15; - // Check node existence - if (!attribute_store_node_exists(user_unique_id_node)) { - sl_log_error(LOG_TAG, - "Can't find user with ID %d in CREDENTIAL_REPORT", - user_id); - return SL_STATUS_NOT_SUPPORTED; - } - - // Find credential type node based on user id and credential type - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; + try { + zwave_frame_parser parser(frame_data, frame_length); - bool credential_type_found = get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); + if (!parser.is_frame_size_valid(min_size, UINT8_MAX)) { + sl_log_error(LOG_TAG, "Invalid frame size for Credential Report frame"); + return SL_STATUS_FAIL; + } - // If not found we look for the credential type node of 0 (first interview) - if (!credential_type_found) { - // We don't care about the return value, if not defined it will be catch soon. - get_credential_type_node(endpoint_node, - user_id, - 0, - REPORTED_ATTRIBUTE, - credential_type_node); - } + credential_report_type_t credential_report_type + = static_cast(parser.read_byte()); + auto user_id = parser.read_sequential(2); + user_credential_type_t credential_type = parser.read_byte(); + auto credential_slot = parser.read_sequential(2); - // Now search for the slot node - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - // Check reported value first - if (!get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node)) { sl_log_debug(LOG_TAG, - "Could not find slot %d with reported value, trying desired", - credential_slot); - // Then check desired value - if (!get_credential_slot_node(credential_type_node, - credential_slot, - DESIRED_ATTRIBUTE, - credential_slot_node)) { - sl_log_debug( - LOG_TAG, - "Could not find slot %d with desired value, using the Slot with ID 0", - credential_slot); - - // If not found it will be checked in the next step - get_credential_slot_node(credential_type_node, - 0, - DESIRED_ATTRIBUTE, - credential_slot_node); - } - } - - // Check if we could retrieve all the node we need - if (!attribute_store_node_exists(credential_type_node) - || !attribute_store_node_exists(credential_slot_node)) { - sl_log_error(LOG_TAG, - "Can't find (Credential Type %d, Credential Slot %d) in " - "CREDENTIAL_REPORT", + "Credential Report (%d). Type %d, Slot %d (User %d)", + credential_report_type, credential_type, - credential_slot); - return SL_STATUS_NOT_SUPPORTED; - } - - // Remove node if it doesn't exist anymore on the end device - if (frame_data[INDEX_CREDENTIAL_MODIFIER_TYPE] == CREDENTIAL_REPORT_DNE) { - sl_log_info( - LOG_TAG, - "Credential Node %d (credential type %d, user %d) doesn't exist " - "anymore, removing it", - credential_slot, - credential_type, - user_id); - attribute_store_delete_node(credential_slot_node); - return SL_STATUS_OK; - } - - // Update credential slot node & type - attribute_store_set_reported(credential_type_node, - &credential_type, - sizeof(credential_type)); - attribute_store_set_reported(credential_slot_node, - &credential_slot, - sizeof(credential_slot)); - // Since the get is listened on the credential slot node we need to clear it - attribute_store_undefine_desired(credential_slot); - - // If there is any leftovers of slot 0 we remove them to prevent infinite loop - remove_credential_type_and_slot_0_if_exists(); - - // Set standard (uint8 & uint16) data - std::vector user_data = { - {ATTRIBUTE(CREDENTIAL_READ_BACK), - INDEX_CREDENTIAL_READ_BACK, - CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, - 7}, - {ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE), INDEX_CREDENTIAL_MODIFIER_TYPE}, - {ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID), INDEX_CREDENTIAL_MODIFIER_NODE_ID}, - }; - - sl_status_t status - = set_reported_attributes(credential_slot_node, frame_data, user_data); + credential_slot, + user_id); - if (status != SL_STATUS_OK) { - return status; - } + // Helper function to clean up pending credentials slot nodes + auto clean_up_pending_credentials_slot_nodes = [&]() { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, DESIRED_OR_REPORTED_ATTRIBUTE}, + {credential_slot, DESIRED_ATTRIBUTE}); - status - = attribute_store_set_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - &frame_data[INDEX_CREDENTIAL_DATA], - credential_length); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, "Can't set CREDENTIAL_DATA in attribute store"); - return SL_STATUS_NOT_SUPPORTED; - } + nodes.slot_node.delete_node(); + }; - user_credential_type_t next_credential_type - = frame_data[INDEX_NEXT_CREDENTIAL_TYPE]; - user_credential_slot_t next_credential_slot - = get_uint16_value(frame_data, INDEX_NEXT_CREDENTIAL_SLOT); + // We should have a valid user id if we receive this report + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - if (next_credential_type != 0 && next_credential_slot != 0) { - if (!is_credential_available(endpoint_node, - next_credential_type, - next_credential_slot)) { - sl_log_debug(LOG_TAG, - "Next credential is already known, skipping discovery."); - return SL_STATUS_OK; - } + attribute_store::attribute credential_type_node; + attribute_store::attribute credential_slot_node; - trigger_get_credential(user_unique_id_node, - next_credential_type, - next_credential_slot); - sl_log_debug(LOG_TAG, - "Next credential type and slot: %d, %d", - next_credential_type, - next_credential_slot); - } else { - sl_log_debug(LOG_TAG, "No more credential to get"); - } - - return SL_STATUS_OK; -} - -sl_status_t - zwave_command_class_user_credential_credential_set_error_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - if (frame_length < 13) { - sl_log_warning(LOG_TAG, - "CREDENTIAL_SET_ERROR_REPORT frame length is not valid"); - return SL_STATUS_NOT_SUPPORTED; - } + switch (credential_report_type) { + case credential_report_type_t::CREDENTIAL_ADDED: + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential already exists. Can't add credential Type " + "%d, Slot %d (User %d)", + credential_type, + credential_slot, + user_id); + return SL_STATUS_FAIL; + } else { + credential_type_node + = create_or_update_desired_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + credential_slot_node + = create_or_update_desired_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + } + break; + case credential_report_type_t::CREDENTIAL_MODIFIED: { + // Should throw an exception if the credential doesn't exists + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + credential_type_node = nodes.type_node; + credential_slot_node = nodes.slot_node; + // Clear desired value + credential_slot_node.clear_desired(); + credential_slot_node.set_reported(credential_slot); + } break; + case credential_report_type_t::CREDENTIAL_DELETED: + return handle_credential_deletion(endpoint_node, + user_id_node, + user_id, + credential_type, + credential_slot); + case credential_report_type_t::CREDENTIAL_UNCHANGED: + sl_log_info(LOG_TAG, + "Credential Unchanged. Type %d, Slot %d (User %d)", + credential_type, + credential_slot, + user_id); + return SL_STATUS_OK; + // Update desired value if found, otherwise create the nodes + case credential_report_type_t::RESPONSE_TO_GET: + credential_type_node + = create_or_update_desired_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + credential_slot_node + = create_or_update_desired_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + break; + case credential_report_type_t::CREDENTIAL_ADD_REJECTED_LOCATION_OCCUPIED: + sl_log_error(LOG_TAG, + "Credential data rejected as it already exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + clean_up_pending_credentials_slot_nodes(); + return SL_STATUS_OK; + case credential_report_type_t::CREDENTIAL_MODIFY_REJECTED_LOCATION_EMPTY: + sl_log_error( + LOG_TAG, + "Credential data cannot be modified as it does not exists : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); - // We don't need the rest of the frame, we just ensure that the attribute store is valid - uint8_t error_code = frame_data[2]; - user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 3); - user_credential_type_t credential_type = frame_data[5]; - user_credential_slot_t credential_slot = get_uint16_value(frame_data, 6); + credential_type_node + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + DESIRED_OR_REPORTED_ATTRIBUTE); + + if (!credential_type_node.is_valid()) { + sl_log_debug( + LOG_TAG, + "No credential type found for user %d, credential type %d", + user_id, + credential_type); + return SL_STATUS_OK; + } - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); - attribute_store_node_t credential_type_node; - attribute_store_node_t credential_slot_node; + credential_slot_node = credential_type_node.child_by_type_and_value( + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); - auto remove_credential_slot_if_possible - = [&](attribute_store_node_t credential_slot_node) { - if (attribute_store_node_exists(credential_slot_node)) { - sl_log_debug(LOG_TAG, - "Removing credential slot : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); - attribute_store_delete_node(credential_slot_node); - } else { - sl_log_debug(LOG_TAG, - "No credential slot found for user %d, credential type " - "%d, credential slot %d", + credential_slot_node.delete_node(); + return SL_STATUS_OK; + // Duplicate Credential : 0x02 + case credential_report_type_t::CREDENTIAL_DUPLICATE_ERROR: + // Do nothing, the credential GET will clean up for us + sl_log_warning(LOG_TAG, + "Duplicate Credential for user %d, credential type %d, " + "credential slot %d", user_id, credential_type, credential_slot); - } - }; - switch (error_code) { - // Credential Add Rejected Location Occupied : 0x00 - // If attempting to add a credential where a credential of that Credential Type at that Credential Slot already exists, and the new credential data differs - case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALADDREJECTEDLOCATIONOCCUPIED: - sl_log_error(LOG_TAG, - "Credential data rejected as it already exists : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); - // Try to find the node in the store - get_credential_type_node(endpoint_node, - user_id, - credential_type, - DESIRED_ATTRIBUTE, - credential_type_node); - if (!attribute_store_node_exists(credential_type_node)) { - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - } - get_credential_slot_node(credential_type_node, - credential_slot, - DESIRED_ATTRIBUTE, - credential_slot_node); + // This should contains the duplicated credential + clean_up_pending_credentials_slot_nodes(); + return SL_STATUS_OK; + case credential_report_type_t::CREDENTIAL_MANUFACTURER_SECURITY_RULE: + sl_log_warning( + LOG_TAG, + "Credential data rejected as it doesn't respect manufacturer " + "security rules : user %d, credential type %d, " + "credential slot %d", + user_id, + credential_type, + credential_slot); + // This should contains the faulty credential + clean_up_pending_credentials_slot_nodes(); + return SL_STATUS_OK; + case credential_report_type_t::CREDENTIAL_LOCATION_ALREADY_ASSIGNED: + sl_log_warning( + LOG_TAG, + "Credential data rejected as location is already assigned : user %d, " + "credential type %d, credential slot %d", + user_id, + credential_type, + credential_slot); + // This should contains the faulty credential + clean_up_pending_credentials_slot_nodes(); + return SL_STATUS_OK; + case credential_report_type_t::CREDENTIAL_DUPLICATE_ADMIN_CODE: + // TODO : Handle this case + default: + sl_log_error(LOG_TAG, + "Invalid credential report type %d", + credential_report_type); + return SL_STATUS_FAIL; + } - remove_credential_slot_if_possible(credential_slot_node); - break; - // Credential Modify Rejected Location Empty : 0x01 - case CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY: - sl_log_error( - LOG_TAG, - "Credential data cannot be modified as it does not exists : user %d, " - "credential type %d, credential slot %d", - user_id, - credential_type, - credential_slot); - - // Try to find the node in the store - get_credential_type_node(endpoint_node, - user_id, - credential_type, - DESIRED_ATTRIBUTE, - credential_type_node); - if (!attribute_store_node_exists(credential_type_node)) { - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - } + if (!credential_type_node.is_valid()) { + sl_log_critical(LOG_TAG, + "Credential type is invalid when it should be. Can't " + "process credential report."); + return SL_STATUS_FAIL; + } - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_debug(LOG_TAG, - "No credential type found for user %d, credential type %d", - user_id, - credential_type); - return SL_STATUS_OK; - } + if (!credential_slot_node.is_valid()) { + sl_log_critical(LOG_TAG, + "Credential slot is invalid when it should be. Can't " + "process credential report."); + return SL_STATUS_FAIL; + } - get_credential_slot_node(credential_type_node, - credential_slot, - DESIRED_ATTRIBUTE, - credential_slot_node); - if (!attribute_store_node_exists(credential_slot_node)) { - get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - } + // If we are here it means that we have a valid credential type and slot node + parser.read_byte_with_bitmask( + {CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_READ_BACK))}); + uint8_t cred_data_size = parser.read_byte(); + parser.read_sequential>( + cred_data_size, + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA))); + parser.read_byte( + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_MODIFIER_TYPE))); + parser.read_sequential( + 2, + credential_slot_node.emplace_node( + ATTRIBUTE(CREDENTIAL_MODIFIER_NODE_ID))); - remove_credential_slot_if_possible(credential_slot_node); - break; - // Duplicate Credential : 0x02 - case CREDENTIAL_SET_ERROR_REPORT_DUPLICATECREDENTIAL: - // Do nothing, the credential GET will clean up for us - sl_log_warning(LOG_TAG, - "Duplicate Credential for user %d, credential type %d, " - "credential slot %d", - user_id, - credential_type, - credential_slot); - break; - // Manufacturer Security Rules : 0x03 - case CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES: - // Do nothing, the credential GET will clean up for us - sl_log_warning( - LOG_TAG, - "Credential data rejected as it doesn't respect manufacturer " - "security rules : user %d, credential type %d, " - "credential slot %d", - user_id, - credential_type, - credential_slot); - break; + // Next + user_credential_type_t next_credential_type = parser.read_byte(); + auto next_credential_slot + = parser.read_sequential(2); + + // Interview next credential is available + if (next_credential_type != 0 && next_credential_slot != 0 + && credential_report_type + == credential_report_type_t::RESPONSE_TO_GET) { + trigger_get_credential(user_id_node, + next_credential_type, + next_credential_slot); + } + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } return SL_STATUS_OK; @@ -3254,17 +2768,9 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( // Otherwise we just update the reported value case user_report_type_t::RESPONSE_TO_GET: current_user_id_node - = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id, - DESIRED_ATTRIBUTE); - if (!current_user_id_node.is_valid()) { - current_user_id_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - } else { - current_user_id_node.set_reported(current_user_id); - current_user_id_node.clear_desired(); - } + = create_or_update_desired_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); break; // We should have a record of given user ID case user_report_type_t::USER_MODIFIED: @@ -3277,7 +2783,6 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( case user_report_type_t::USER_UNCHANGED: sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); return SL_STATUS_OK; - break; case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: sl_log_warning(LOG_TAG, "User %d was not added since it already exists. Try to " @@ -3362,68 +2867,68 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( return SL_STATUS_OK; } -sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - if (frame_length < 14) { - sl_log_warning(LOG_TAG, "USER_SET_ERROR_REPORT frame length is not valid"); - return SL_STATUS_NOT_SUPPORTED; - } - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); - - // We don't need the rest of the frame, we just ensure that the attribute store is in a valid state - uint8_t error_code = frame_data[2]; - user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 6); - - auto remove_user_node_if_possible = - [&](attribute_store_node_t user_unique_id_node) { - if (attribute_store_node_exists(user_unique_id_node)) { - sl_log_debug(LOG_TAG, "Remove faulty user state", user_id); - attribute_store_delete_node(user_unique_id_node); - } else { - sl_log_debug( - LOG_TAG, - "Didn't find an user with id %d in desired state. Not doing anything", - user_id); - } - }; - - // This case should not happens often since we are doing preemptive checks - switch (error_code) { - // USER_ADD_REJECTED_LOCATION_OCCUPIED : 0x00 - //A user add operation is rejected due to the User Unique Identifier already being occupied - case USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED: { - sl_log_error(LOG_TAG, - "Error when setting user : user ID %d is not available. Try " - "to modify it instead.", - user_id); - // It should be in desired state since we are using ADD operation - attribute_store_node_t user_unique_id_node - = get_desired_user_id_node(endpoint_node, user_id); - remove_user_node_if_possible(user_unique_id_node); - } break; - // USER_MODIFY_REJECTED_LOCATION_EMPTY : 0x01 - // A user modify operation is rejected due to the User Unique Identifier location being empty - case USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY: { - sl_log_error(LOG_TAG, - "Error when modifying user : user ID %d does not exists.", - user_id); - // Hunt down the invalid user ID and remove it - attribute_store_node_t user_unique_id_node - = get_desired_user_id_node(endpoint_node, user_id); - // Check for reported value if it doesn't exists - if (!attribute_store_node_exists(user_unique_id_node)) { - user_unique_id_node = get_reported_user_id_node(endpoint_node, user_id); - } - remove_user_node_if_possible(user_unique_id_node); - } break; - } - - return SL_STATUS_OK; -} +// sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( +// const zwave_controller_connection_info_t *connection_info, +// const uint8_t *frame_data, +// uint16_t frame_length) +// { +// if (frame_length < 14) { +// sl_log_warning(LOG_TAG, "USER_SET_ERROR_REPORT frame length is not valid"); +// return SL_STATUS_NOT_SUPPORTED; +// } +// attribute_store_node_t endpoint_node +// = zwave_command_class_get_endpoint_node(connection_info); + +// // We don't need the rest of the frame, we just ensure that the attribute store is in a valid state +// uint8_t error_code = frame_data[2]; +// user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 6); + +// auto remove_user_node_if_possible = +// [&](attribute_store_node_t user_unique_id_node) { +// if (attribute_store_node_exists(user_unique_id_node)) { +// sl_log_debug(LOG_TAG, "Remove faulty user state", user_id); +// attribute_store_delete_node(user_unique_id_node); +// } else { +// sl_log_debug( +// LOG_TAG, +// "Didn't find an user with id %d in desired state. Not doing anything", +// user_id); +// } +// }; + +// // This case should not happens often since we are doing preemptive checks +// switch (error_code) { +// // USER_ADD_REJECTED_LOCATION_OCCUPIED : 0x00 +// //A user add operation is rejected due to the User Unique Identifier already being occupied +// case USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED: { +// sl_log_error(LOG_TAG, +// "Error when setting user : user ID %d is not available. Try " +// "to modify it instead.", +// user_id); +// // It should be in desired state since we are using ADD operation +// attribute_store_node_t user_unique_id_node +// = get_desired_user_id_node(endpoint_node, user_id); +// remove_user_node_if_possible(user_unique_id_node); +// } break; +// // USER_MODIFY_REJECTED_LOCATION_EMPTY : 0x01 +// // A user modify operation is rejected due to the User Unique Identifier location being empty +// case USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY: { +// sl_log_error(LOG_TAG, +// "Error when modifying user : user ID %d does not exists.", +// user_id); +// // Hunt down the invalid user ID and remove it +// attribute_store_node_t user_unique_id_node +// = get_desired_user_id_node(endpoint_node, user_id); +// // Check for reported value if it doesn't exists +// if (!attribute_store_node_exists(user_unique_id_node)) { +// user_unique_id_node = get_reported_user_id_node(endpoint_node, user_id); +// } +// remove_user_node_if_possible(user_unique_id_node); +// } break; +// } + +// return SL_STATUS_OK; +// } ///////////////////////////////////////////////////////////////////////////// // Checksum helpers @@ -4191,20 +3696,20 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - // Get or create credential type node - credential_type_node = add_credential_type_node_if_missing(endpoint_node, - user_id, - credential_type); - - if (!attribute_store_node_exists(credential_type_node)) { + attribute_store::attribute user_id_node; + try { + user_id_node = get_reported_user_id_node(endpoint_node, user_id); + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't find Credential Type %d for User %d. Not adding " - "credentials.", - credential_type, + "Can't find User %d. Not adding credentials.", user_id); return SL_STATUS_FAIL; } + // Get or create credential type node + credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + // Debug info sl_log_debug( LOG_TAG, @@ -4864,16 +4369,6 @@ sl_status_t zwave_command_class_user_credential_control_handler( } switch (frame_data[COMMAND_INDEX]) { - case USER_SET_ERROR_REPORT: - return zwave_command_class_user_credential_user_set_error_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_SET_ERROR_REPORT: - return zwave_command_class_user_credential_credential_set_error_handle_report( - connection_info, - frame_data, - frame_length); case USER_CAPABILITIES_REPORT: return zwave_command_class_user_credential_user_capabilities_handle_report( connection_info, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 65b5a1a31..84e3e2a3a 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -78,9 +78,6 @@ const zwave_struct_handler_args command_class_handler .supported_version = USER_CREDENTIAL_VERSION, .scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS}; -// Notification callback -static notification_event_callback_t notification_callback; - ///////////////////////////////////////////////////// // HELPERS ///////////////////////////////////////////////////// @@ -134,30 +131,6 @@ credential_structure_nodes helper_create_credential_structure( // Report helpers //////////////////////////////////////////////////// -void helper_simulate_credential_set_error_report( - uint8_t credential_set_error_type, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - uint8_t crb, - std::string credential_data, - user_credential_modifier_type_t modifier_type, - user_credential_modifier_node_id_t modifier_node_id) -{ - zwave_frame report_frame; - - report_frame.add(credential_set_error_type); - report_frame.add(user_id); - report_frame.add(credential_type); - report_frame.add(credential_slot); - report_frame.add(crb); - report_frame.add(credential_data); - report_frame.add(modifier_type); - report_frame.add(modifier_node_id); - - helper_test_report_frame(CREDENTIAL_SET_ERROR_REPORT, report_frame); -} - void helper_simulate_user_capabilites_report( uint16_t number_of_users, user_credential_supported_credential_rules_t cred_rule_bitmask, @@ -300,7 +273,6 @@ void helper_simulate_association_report_frame( helper_test_report_frame(USER_CREDENTIAL_ASSOCIATION_REPORT, report_frame); } - void helper_test_credential_learn_structure( attribute_store::attribute user_id_node, attribute_store::attribute credential_type_node, @@ -416,6 +388,7 @@ void helper_test_credential_data( } void helper_simulate_credential_report_frame( + uint8_t credential_report_type, user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot, @@ -428,7 +401,7 @@ void helper_simulate_credential_report_frame( sl_status_t expected_status = SL_STATUS_OK) { zwave_frame report_frame; - + report_frame.add(credential_report_type); report_frame.add(user_id); report_frame.add(credential_type); report_frame.add(credential_slot); @@ -442,6 +415,11 @@ void helper_simulate_credential_report_frame( helper_test_report_frame(CREDENTIAL_REPORT, report_frame, expected_status); }; +std::vector string_to_uint8_vector(const std::string &str) +{ + return std::vector(str.begin(), str.end()); +} + void helper_create_credential_checksum_structure() { // Since credential are attached to an user we simulate somes users @@ -497,16 +475,8 @@ void helper_create_credential_checksum_structure() } for (size_t i = 0; i < credential_types.size(); i++) { - // Simulate credential type and slot to get the credential report to work - auto user_credential_type_node - = user_id_nodes[credential_user_ids[i]].emplace_node( - ATTRIBUTE(CREDENTIAL_TYPE), - credential_types[i]); - - user_credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slots[i]); - - helper_simulate_credential_report_frame(credential_user_ids[i], + helper_simulate_credential_report_frame(0x00, // Credential Add + credential_user_ids[i], credential_types[i], credential_slots[i], 0, @@ -521,13 +491,6 @@ void helper_create_credential_checksum_structure() ///////////////////////////////////////////////////// // Test case ///////////////////////////////////////////////////// -static void zwave_command_class_notification_register_event_callback_stub( - attribute_store_node_t endpoint_node, - notification_event_callback_t callback, - int cmock_num_calls) -{ - notification_callback = callback; -} /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() @@ -548,16 +511,9 @@ int suiteTearDown(int num_failures) /// Called before each and every test void setUp() { - zwave_network_management_get_node_id_IgnoreAndReturn(zpc_node_id); - zwave_network_management_get_home_id_IgnoreAndReturn(home_id); - zwave_setUp(command_class_handler, &zwave_command_class_user_credential_init, attributes_binding); - - notification_callback = NULL; - zwave_command_class_notification_register_event_callback_Stub( - &zwave_command_class_notification_register_event_callback_stub); } /// Called after each and every test @@ -1249,63 +1205,32 @@ void test_user_credential_credential_report_no_credential() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Should return ok since credential_type and credential node is 0 - helper_simulate_credential_report_frame(user_id, 0, 0, 0, {}, 0, 0, 0, 0); -} - -void test_user_credential_credential_report_missing_user() -{ - // Not found since we haven't created any user_unique_id - helper_simulate_credential_report_frame(12, - 1, - 1, - 0, - {}, - 0, - 0, + helper_simulate_credential_report_frame(0x04, // Credential get, + user_id, 0, 0, - SL_STATUS_NOT_SUPPORTED); -} - -void test_user_credential_credential_report_missing_credential_type() -{ - user_credential_user_unique_id_t user_id = 12; - cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - - // Not found since we haven't created any credential_type - helper_simulate_credential_report_frame(user_id, - 1, - 5, 0, {}, 0, 0, 0, - 0, - SL_STATUS_NOT_SUPPORTED); + 0); } -void test_user_credential_credential_report_missing_credential_slot() +void test_user_credential_credential_report_missing_user() { - user_credential_user_unique_id_t user_id = 12; - user_credential_type_t credential_type = 121; - - auto user_id_node - = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - - user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); - - // Not found since we haven't created any credential_slot - helper_simulate_credential_report_frame(user_id, - credential_type, - 1212, + // Not found since we haven't created any user_unique_id + helper_simulate_credential_report_frame(0x04, + 12, + 1, + 1, 0, {}, 0, 0, 0, 0, - SL_STATUS_NOT_SUPPORTED); + SL_STATUS_FAIL); } void test_user_credential_credential_report_happy_case() @@ -1413,7 +1338,8 @@ void test_user_credential_credential_report_happy_case() get_frame); // Call report - helper_simulate_credential_report_frame(user_id, + helper_simulate_credential_report_frame(0x04, // Response to get + user_id, credential_type, credential_slot, crb, @@ -1424,6 +1350,17 @@ void test_user_credential_credential_report_happy_case() next_credential_slot); // Test values + TEST_ASSERT_FALSE_MESSAGE(first_credential_type_node.is_valid(), + "Credential type node 0 should have been deleted"); + TEST_ASSERT_FALSE_MESSAGE(first_credential_slot_node.is_valid(), + "Credential slot node 0 should have been deleted"); + + first_credential_type_node + = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_TYPE), user_id_node); + first_credential_slot_node + = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_SLOT), + first_credential_type_node); + test_credential_values(first_credential_type_node, first_credential_slot_node); // We should have 1 credential type and 2 credential slot @@ -1457,7 +1394,8 @@ void test_user_credential_credential_report_happy_case() get_frame); // Call report - helper_simulate_credential_report_frame(user_id, + helper_simulate_credential_report_frame(0x04, // Response to get + user_id, credential_type, credential_slot, crb, @@ -1503,7 +1441,8 @@ void test_user_credential_credential_report_happy_case() get_frame); // Call report - helper_simulate_credential_report_frame(user_id, + helper_simulate_credential_report_frame(0x04, // Response to get + user_id, credential_type, credential_slot, crb, @@ -1567,6 +1506,9 @@ void test_attribute_creation_no_version() void test_post_interview_discovery() { + zwave_network_management_get_node_id_IgnoreAndReturn(zpc_node_id); + zwave_network_management_get_home_id_IgnoreAndReturn(home_id); + // Lambdas auto count_user_node = [](size_t expected_value) { auto user_id_node_count @@ -1634,50 +1576,11 @@ void test_post_interview_discovery() helper_test_attribute_value(ATTRIBUTE(USER_UNIQUE_ID), user_id); } -void test_user_credential_notification_empty_parameters() -{ - // Initialize the notification callback - helper_set_version(1); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - std::vector empty_event_parameters = {}; - // Test all available notification types - // No error should occurs even if parameters are not well defined - std::vector notification_access_control_event_types = {0x23, - 0x24, - 0x25, - 0x26, - 0x27, - 0x28, - 0x29, - 0x2A, - 0x2B, - 0x2C, - 0x2D, - 0x2E, - 0x2F, - 0x30, - 0x31, - 0x32, - 0x33}; - for (auto event_type: notification_access_control_event_types) { - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - event_type, - empty_event_parameters.data(), - empty_event_parameters.size()); - } -} - void test_user_credential_add_credential_already_defined_cred_type_and_slot() { // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - user_credential_user_unique_id_t user_id = 12; user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; user_credential_slot_t credential_slot = 1; @@ -1687,12 +1590,9 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() user_credential_modifier_node_id_t credential_modifier_node_id = 1212; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - // Se capabilities + // Capabilities uint8_t supported_credential_checksum = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE}; @@ -1721,22 +1621,17 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() status, "Credential add should have returned SL_STATUS_OK"); - // Simulate notification so that the credential is marked as reported - auto credential_notification_report - = helper_create_credential_notification_report(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id); - - // Endpoint send User Add notification - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x2B, // Credential added - credential_notification_report.data(), - credential_notification_report.size()); + helper_simulate_credential_report_frame( + 0x00, // Credential added + user_id, + credential_type, + credential_slot, + crb, + string_to_uint8_vector(credential_data), + credential_modifier_type, + credential_modifier_node_id, + 0, + 0); // Try to add same credential type and slot on same user but with different credential data credential_data = "1234"; @@ -1755,10 +1650,7 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() // Try to add same credential type/slot on other user user_id = 15; - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); status = zwave_command_class_user_credential_add_new_credential( endpoint_id_node, @@ -1782,10 +1674,7 @@ void test_user_credential_add_credential_invalid_slot() std::string credential_data = "12"; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities uint8_t supported_credential_checksum = 1; @@ -1969,17 +1858,9 @@ void test_user_credential_user_add_modify_delete_happy_case() user_name); } -void test_user_credential_credential_notification_add_modify_delete_happy_case() +void test_user_credential_credential_add_modify_delete_happy_case() { - // Initialize the notification callback - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + helper_set_version(1); user_credential_user_unique_id_t user_id = 12; user_credential_type_t credential_type = ZCL_CRED_TYPE_PIN_CODE; @@ -1990,10 +1871,8 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() user_credential_modifier_node_id_t credential_modifier_node_id = 1212; // Simulate user - auto user_id_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities uint8_t supported_credential_checksum = 1; @@ -2026,36 +1905,30 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() // Get credential type auto credential_type_node - = attribute_store_get_first_child_by_type(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); + = user_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_TYPE)); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + TEST_ASSERT_TRUE_MESSAGE(credential_type_node.is_valid(), "Credential type node should exist"); // Get credential slot auto credential_slot_node - = attribute_store_get_first_child_by_type(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); + = credential_type_node.child_by_type(ATTRIBUTE(CREDENTIAL_SLOT)); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_slot_node), + TEST_ASSERT_TRUE_MESSAGE(credential_slot_node.is_valid(), "Credential slot node should exist"); // Create notification report frame - auto credential_notification_report - = helper_create_credential_notification_report(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id); - - // Endpoint send User Add notification - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x2B, // Credential added - credential_notification_report.data(), - credential_notification_report.size()); + helper_simulate_credential_report_frame( + 0x00, // Credential add + user_id, + credential_type, + credential_slot, + crb, + string_to_uint8_vector(credential_data), + credential_modifier_type, + credential_modifier_node_id, + 0, + 0); // Check values auto test_attribute_store_values = [&]() { @@ -2080,35 +1953,36 @@ void test_user_credential_credential_notification_add_modify_delete_happy_case() credential_modifier_node_id = 15; // Modify credential - credential_notification_report - = helper_create_credential_notification_report(user_id, - credential_type, - credential_slot, - crb, - credential_data, - credential_modifier_type, - credential_modifier_node_id); - - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x2C, // Credential modified - credential_notification_report.data(), - credential_notification_report.size()); + helper_simulate_credential_report_frame( + 0x01, // Credential modify + user_id, + credential_type, + credential_slot, + crb, + string_to_uint8_vector(credential_data), + credential_modifier_type, + credential_modifier_node_id, + 0, + 0); test_attribute_store_values(); - // Delete credential - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x2D, // Credential deleted - credential_notification_report.data(), - credential_notification_report.size()); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(credential_slot_node), + helper_simulate_credential_report_frame( + 0x02, // Credential remove + user_id, + credential_type, + credential_slot, + 0, + string_to_uint8_vector(credential_data), + credential_modifier_type, + credential_modifier_node_id, + 0, + 0); + TEST_ASSERT_FALSE_MESSAGE(credential_slot_node.is_valid(), "Credential slot node should be deleted"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(credential_type_node), + TEST_ASSERT_TRUE_MESSAGE(credential_type_node.is_valid(), "Credential type node should still exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_id_node), + TEST_ASSERT_TRUE_MESSAGE(user_id_node.is_valid(), "User ID node should still exist"); } @@ -2117,9 +1991,6 @@ void test_user_credential_user_add_capabilites_failure_cases() // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - // Those functions are exposed and checks user values, so we need to setup the capabilities uint16_t number_of_users = 1; user_credential_supported_credential_rules_t cred_rule_bitmask = 2; @@ -2301,9 +2172,6 @@ void test_user_credential_user_modify_capabilites_failure_cases() // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - // Those functions are exposed and checks user values, so we need to setup the capabilities uint16_t number_of_users = 1; user_credential_supported_credential_rules_t cred_rule_bitmask = 2; @@ -2381,9 +2249,6 @@ void test_user_credential_credential_add_capabilites_failure_cases() // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - user_credential_user_unique_id_t user_id = 12; // Simulate user @@ -2457,16 +2322,10 @@ void test_user_credential_credential_add_capabilites_happy_case() // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - user_credential_user_unique_id_t user_id = 12; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities uint8_t supported_credential_checksum = 1; @@ -2511,16 +2370,10 @@ void test_user_credential_credential_modify_capabilites_failure_cases() // Initialize the notification callback helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - user_credential_user_unique_id_t user_id = 12; // Simulate user - attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities uint8_t supported_credential_checksum = 1; @@ -2569,233 +2422,79 @@ void test_user_credential_credential_modify_capabilites_failure_cases() "Should not be able to modify credential data : it's too long"); } -// TODO : to be refactored -void test_user_credential_credential_set_error_report_cred_add_happy_case() -{ - user_credential_user_unique_id_t user_id = 12; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 1; - - auto valid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - auto valid_cred_type_node - = attribute_store_emplace(valid_user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - auto invalid_cred_slot_node - = attribute_store_emplace_desired(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - helper_simulate_credential_set_error_report( - CREDENTIAL_SET_ERROR_REPORT_CREDENTIALADDREJECTEDLOCATIONOCCUPIED, - user_id, - credential_type, - credential_slot, - 1, - "1212", - 1, - 2); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node should not exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); -} - -// TODO : to be refactored -void test_user_credential_credential_set_error_report_cred_modify_happy_case() +void helper_test_credential_rejected_case(uint8_t report_type) { user_credential_user_unique_id_t user_id = 12; user_credential_type_t credential_type = 1; user_credential_slot_t credential_slot = 1; - auto valid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - auto valid_cred_type_node - = attribute_store_emplace(valid_user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - auto invalid_cred_slot_node - = attribute_store_emplace_desired(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - helper_simulate_credential_set_error_report( - CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY, - user_id, - credential_type, - credential_slot, - 1, - "1212", - 1, - 2); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node should not exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); - - invalid_cred_slot_node = attribute_store_emplace(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - helper_simulate_credential_set_error_report( - CREDENTIAL_SET_ERROR_REPORT_CREDENTIALMODIFYREJECTEDLOCATIONEMPTY, - user_id, - credential_type, - credential_slot, - 1, - "1212", - 1, - 2); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node should not exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); -} - -// TODO : to be refactored -void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() -{ - user_credential_user_unique_id_t user_id = 12; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 1; - - auto valid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + auto valid_user_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); auto valid_cred_type_node - = attribute_store_emplace(valid_user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); + = valid_user_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + auto valid_cred_slot_node + = valid_cred_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + REPORTED_ATTRIBUTE); auto invalid_cred_slot_node - = attribute_store_emplace_desired(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - helper_simulate_credential_set_error_report( - CREDENTIAL_SET_ERROR_REPORT_DUPLICATECREDENTIAL, - user_id, - credential_type, - credential_slot, - 1, - "1212", - 1, - 2); - - // Here the Credential Report command should remove this not this report - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node SHOULD exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); - - // Now actually send the report - std::vector cred_data = {1, 2, 3, 4}; + = valid_cred_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); - // Do the report - helper_simulate_credential_report_frame(user_id, + helper_simulate_credential_report_frame(report_type, // Duplicate credential + user_id, credential_type, credential_slot, 1, - cred_data, - CREDENTIAL_REPORT_DNE, + string_to_uint8_vector("1212"), + 0, 2, 0, 0); - // Now it should not exists - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), + // Here the Credential Report command should remove this not this report + TEST_ASSERT_FALSE_MESSAGE(invalid_cred_slot_node.is_valid(), "Invalid Credential Slot node should NOT exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), + TEST_ASSERT_TRUE_MESSAGE(valid_cred_slot_node.is_valid(), + "Valid Credential Slot node SHOULD exist"); + TEST_ASSERT_TRUE_MESSAGE(valid_cred_type_node.is_valid(), "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), + TEST_ASSERT_TRUE_MESSAGE(valid_user_node.is_valid(), "Valid Credential type node should exist"); } -// TODO : to be refactored -// Note : same as test_user_credential_credential_set_error_report_cred_duplicate_happy_case -// but with CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES in the report -void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() +void test_user_credential_credential_set_error_report_cred_add_happy_case() { - user_credential_user_unique_id_t user_id = 12; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 1; - - auto valid_user_node = attribute_store_emplace(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - auto valid_cred_type_node - = attribute_store_emplace(valid_user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - auto invalid_cred_slot_node - = attribute_store_emplace_desired(valid_cred_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - helper_simulate_credential_set_error_report( - CREDENTIAL_SET_ERROR_REPORT_MANUFACTURERSECURITYRULES, - user_id, - credential_type, - credential_slot, - 1, - "1212", - 1, - 2); + helper_test_credential_rejected_case(0x05); +} - // Here the Credential Report command should remove this not this report - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node SHOULD exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); +void test_user_credential_credential_set_error_report_cred_modify_happy_case() +{ + // Common case + helper_test_credential_rejected_case(0x06); - // Now actually send the report - std::vector cred_data = {1, 2, 3, 4}; - helper_simulate_credential_report_frame(user_id, - credential_type, - credential_slot, + // See if that works even without credential type + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), 12); + helper_simulate_credential_report_frame(0x06, + 12, + 5, 1, - cred_data, - CREDENTIAL_REPORT_DNE, - 2, + 1, + string_to_uint8_vector("1212"), + 0, + 0, 0, 0); +} - // Now it should not exists - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(invalid_cred_slot_node), - "Invalid Credential Slot node should NOT exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_cred_type_node), - "Valid User node should exist"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(valid_user_node), - "Valid Credential type node should exist"); +void test_user_credential_credential_set_error_report_cred_duplicate_happy_case() +{ + helper_test_credential_rejected_case(0x07); +} + +void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() +{ + helper_test_credential_rejected_case(0x08); } void test_user_credential_remove_all_users_happy_case() @@ -2847,9 +2546,6 @@ void test_user_credential_remove_all_credentials_happy_case() { helper_set_version(1); - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); - std::vector expected_nodes; // WARNING : All those vectors should be the same size std::vector user_ids = {12, 12, 12, 15, 19}; @@ -2873,48 +2569,42 @@ void test_user_credential_remove_all_credentials_happy_case() status, "Remove all credentials should have returned SL_STATUS_OK"); - std::vector notification_parameters = {0, 0, 0, 0, 0}; - // This will handle the deletion - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x26, // All Credential deleted - // No need to have arguments here - notification_parameters.data(), - notification_parameters.size()); + helper_simulate_credential_report_frame(0x02, 0, 0, 0, 0, {}, 0, 0, 0, 0); for (auto &node: expected_nodes) { - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(node.credential_type_node), - "Credential type node should have been removed"); - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(node.credential_slot_node), - "Credential slot node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE(node.credential_type_node.is_valid(), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE(node.credential_slot_node.is_valid(), + "Credential slot node should have been removed"); } +} - user_credential_user_unique_id_t user_id = 0; - auto user_0_node - = attribute_store_get_node_child_by_value(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), - "User 0 should not exists"); +/** + * @brief Test the removal of credentials of a user + * + * @param nodes Nodes to tests + * @param deletion_condition If true will test if credential types and slots have been removed, otherwise will test if they still exist + * + */ +void helper_test_credential_structure_exists(credential_structure_nodes nodes, + bool deletion_condition) +{ + if (deletion_condition) { + TEST_ASSERT_FALSE_MESSAGE(nodes.credential_type_node.is_valid(), + "Credential type node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE(nodes.credential_slot_node.is_valid(), + "Credential slot node should have been removed"); + } else { + TEST_ASSERT_TRUE_MESSAGE(nodes.credential_type_node.is_valid(), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE(nodes.credential_slot_node.is_valid(), + "Credential slot node should still exist"); + } } -// TODO : to be refactored void test_user_credential_remove_all_credentials_of_user() { - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + helper_set_version(1); user_credential_user_unique_id_t user_to_delete = 12; @@ -2944,78 +2634,38 @@ void test_user_credential_remove_all_credentials_of_user() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - zwave_frame notification_parameters; - notification_parameters.add(user_to_delete); - for (size_t i = 0; i < 3; i++) { - notification_parameters.add(static_cast(0)); - } - - // This will handle the deletion - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x26, // All Credential deleted - // No need to have arguments here - notification_parameters.data(), - notification_parameters.size()); - - attribute_store_log(); + helper_simulate_credential_report_frame(0x02, + user_to_delete, + 0, + 0, + 0, + {}, + 0, + 0, + 0, + 0); for (auto &node: expected_nodes) { - user_credential_user_unique_id_t reported_user_id; - attribute_store_get_reported(node.user_id_node, - &reported_user_id, - sizeof(reported_user_id)); + auto reported_user_id + = node.user_id_node.reported(); node.print(); - if (reported_user_id == user_to_delete) { - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(node.credential_type_node), - "Credential type node should have been removed"); - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(node.credential_slot_node), - "Credential slot node should have been removed"); - } else { - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(node.credential_type_node), - "Credential type node should still exist"); - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(node.credential_slot_node), - "Credential slot node should still exist"); - } + helper_test_credential_structure_exists(node, + reported_user_id == user_to_delete); } - - user_credential_user_unique_id_t user_id = 0; - auto user_0_node - = attribute_store_get_node_child_by_value(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), - "User 0 should not exists"); } -// TODO : to be refactored +struct expected_node_data { + credential_structure_nodes nodes; + bool deletion_condition; +}; void test_user_credential_remove_all_credentials_of_user_by_type() { - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + helper_set_version(1); user_credential_user_unique_id_t user_to_delete = 12; user_credential_type_t credential_type_to_delete = 1; - struct expected_node_data { - credential_structure_nodes nodes; - bool should_not_exist; - }; std::vector expected_nodes_data; // WARNING : All those vectors should be the same size std::vector user_ids @@ -3046,77 +2696,32 @@ void test_user_credential_remove_all_credentials_of_user_by_type() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - zwave_frame notification_parameters; - notification_parameters.add(user_to_delete); - notification_parameters.add(credential_type_to_delete); - for (size_t i = 0; i < 2; i++) { - notification_parameters.add(static_cast(0)); - } - - // This will handle the deletion - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x26, // All Credential deleted - // No need to have arguments here - notification_parameters.data(), - notification_parameters.size()); - - attribute_store_log(); + helper_simulate_credential_report_frame(0x02, + user_to_delete, + credential_type_to_delete, + 0, + 0, + {}, + 0, + 0, + 0, + 0); for (auto &node_data: expected_nodes_data) { - auto nodes = node_data.nodes; - auto should_not_exist = node_data.should_not_exist; + auto nodes = node_data.nodes; + auto deletion_condition = node_data.deletion_condition; nodes.print(); - - if (should_not_exist) { - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(nodes.credential_type_node), - "Credential type node should have been removed"); - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(nodes.credential_slot_node), - "Credential slot node should have been removed"); - } else { - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(nodes.credential_type_node), - "Credential type node should still exist"); - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(nodes.credential_slot_node), - "Credential slot node should still exist"); - } + helper_test_credential_structure_exists(nodes, deletion_condition); } - - user_credential_user_unique_id_t user_id = 0; - auto user_0_node - = attribute_store_get_node_child_by_value(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), - "User 0 should not exists"); } -// TODO : to be refactored void test_user_credential_remove_all_credentials_by_type() { - const zwave_cc_version_t version = 1; - attribute_store_set_child_reported(endpoint_id_node, - ATTRIBUTE(VERSION), - &version, - sizeof(version)); - - TEST_ASSERT_NOT_NULL_MESSAGE(notification_callback, - "Notification callback should be defined"); + helper_set_version(1); user_credential_type_t credential_type_to_delete = 1; - struct expected_node_data { - credential_structure_nodes nodes; - bool should_not_exist; - }; std::vector expected_nodes_data; // WARNING : All those vectors should be the same size std::vector user_ids = {12, 12, 12, 15, 19}; @@ -3148,53 +2753,24 @@ void test_user_credential_remove_all_credentials_by_type() status, "Remove all credentials for user should have returned SL_STATUS_OK"); - std::vector notification_parameters - = {0, 0, credential_type_to_delete, 0, 0}; - - // This will handle the deletion - notification_callback(endpoint_id_node, - NOTIFICATION_ACCESS_CONTROL, - 0x26, // All Credential deleted - // No need to have arguments here - notification_parameters.data(), - notification_parameters.size()); - - attribute_store_log(); + helper_simulate_credential_report_frame(0x02, + 0, + credential_type_to_delete, + 0, + 0, + {}, + 0, + 0, + 0, + 0); for (auto &node_data: expected_nodes_data) { - auto nodes = node_data.nodes; - auto should_not_exist = node_data.should_not_exist; + auto nodes = node_data.nodes; + auto deletion_condition = node_data.deletion_condition; nodes.print(); - - if (should_not_exist) { - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(nodes.credential_type_node), - "Credential type node should have been removed"); - TEST_ASSERT_FALSE_MESSAGE( - attribute_store_node_exists(nodes.credential_slot_node), - "Credential slot node should have been removed"); - } else { - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(nodes.credential_type_node), - "Credential type node should still exist"); - TEST_ASSERT_TRUE_MESSAGE( - attribute_store_node_exists(nodes.credential_slot_node), - "Credential slot node should still exist"); - } + helper_test_credential_structure_exists(nodes, deletion_condition); } - - user_credential_user_unique_id_t user_id = 0; - auto user_0_node - = attribute_store_get_node_child_by_value(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - TEST_ASSERT_FALSE_MESSAGE(attribute_store_node_exists(user_0_node), - "User 0 should not exists"); } void test_user_credential_credential_learn_start_add_happy_case() @@ -4123,6 +3699,7 @@ void test_get_user_checksum_with_credentials_happy_case() for (size_t i = 0; i < credential_types.size(); i++) { helper_simulate_credential_report_frame( + 0x00, user_id, credential_types[i], credential_slots[i], @@ -4226,7 +3803,6 @@ void test_get_user_checksum_without_credentials_mismatch_checksum() user_get_frame.add(user_id); helper_test_get_set_frame_happy_case(USER_GET, user_id_node, user_get_frame); - helper_simulate_user_report_frame(0x04, 0, 0x02, // Z-Wave From a4590daae91c365d3e9c1e034af04ad17532f3c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 28 Aug 2024 17:09:58 +0200 Subject: [PATCH 31/60] UIC-3222: Remove user set error command --- .../zwave_command_class_user_credential.cpp | 63 ------------------- 1 file changed, 63 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 4b14075f8..0f3ae4a75 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -2867,69 +2867,6 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( return SL_STATUS_OK; } -// sl_status_t zwave_command_class_user_credential_user_set_error_handle_report( -// const zwave_controller_connection_info_t *connection_info, -// const uint8_t *frame_data, -// uint16_t frame_length) -// { -// if (frame_length < 14) { -// sl_log_warning(LOG_TAG, "USER_SET_ERROR_REPORT frame length is not valid"); -// return SL_STATUS_NOT_SUPPORTED; -// } -// attribute_store_node_t endpoint_node -// = zwave_command_class_get_endpoint_node(connection_info); - -// // We don't need the rest of the frame, we just ensure that the attribute store is in a valid state -// uint8_t error_code = frame_data[2]; -// user_credential_user_unique_id_t user_id = get_uint16_value(frame_data, 6); - -// auto remove_user_node_if_possible = -// [&](attribute_store_node_t user_unique_id_node) { -// if (attribute_store_node_exists(user_unique_id_node)) { -// sl_log_debug(LOG_TAG, "Remove faulty user state", user_id); -// attribute_store_delete_node(user_unique_id_node); -// } else { -// sl_log_debug( -// LOG_TAG, -// "Didn't find an user with id %d in desired state. Not doing anything", -// user_id); -// } -// }; - -// // This case should not happens often since we are doing preemptive checks -// switch (error_code) { -// // USER_ADD_REJECTED_LOCATION_OCCUPIED : 0x00 -// //A user add operation is rejected due to the User Unique Identifier already being occupied -// case USER_SET_ERROR_REPORT_USERADDREJECTEDLOCATIONOCCUPIED: { -// sl_log_error(LOG_TAG, -// "Error when setting user : user ID %d is not available. Try " -// "to modify it instead.", -// user_id); -// // It should be in desired state since we are using ADD operation -// attribute_store_node_t user_unique_id_node -// = get_desired_user_id_node(endpoint_node, user_id); -// remove_user_node_if_possible(user_unique_id_node); -// } break; -// // USER_MODIFY_REJECTED_LOCATION_EMPTY : 0x01 -// // A user modify operation is rejected due to the User Unique Identifier location being empty -// case USER_SET_ERROR_REPORT_USERMODIFYREJECTEDLOCATIONEMPTY: { -// sl_log_error(LOG_TAG, -// "Error when modifying user : user ID %d does not exists.", -// user_id); -// // Hunt down the invalid user ID and remove it -// attribute_store_node_t user_unique_id_node -// = get_desired_user_id_node(endpoint_node, user_id); -// // Check for reported value if it doesn't exists -// if (!attribute_store_node_exists(user_unique_id_node)) { -// user_unique_id_node = get_reported_user_id_node(endpoint_node, user_id); -// } -// remove_user_node_if_possible(user_unique_id_node); -// } break; -// } - -// return SL_STATUS_OK; -// } - ///////////////////////////////////////////////////////////////////////////// // Checksum helpers ///////////////////////////////////////////////////////////////////////////// From 6aeebbde9a531b557f6377fa4cd7deb27a6e2412 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 29 Aug 2024 11:31:05 +0200 Subject: [PATCH 32/60] UIC-3222: Refactor User interview --- .../zwave_command_class_user_credential.cpp | 150 ++++++------------ 1 file changed, 49 insertions(+), 101 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 0f3ae4a75..b05a64927 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -85,18 +85,6 @@ namespace zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); } -///////////////////////////////////////////////////////////////////////////// -// Preemptive declarations -///////////////////////////////////////////////////////////////////////////// -/** - * @brief Trigger an User Get for given user_id - * - * @param endpoint_node Endpoint node - * @param user_id User ID. Can be set to 0 to discover users -*/ -void trigger_get_user(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id); - ///////////////////////////////////////////////////////////////////////////// // Data struct ///////////////////////////////////////////////////////////////////////////// @@ -2509,39 +2497,6 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // User Set/Get/Report/Set Error Report ///////////////////////////////////////////////////////////////////////////// -// Start user interview process by starting a user get with ID 0 -void trigger_get_user(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) -{ - // If we are not in the special case of user ID 0 we need to check if user is already here - if (user_id != 0) { - attribute_store_node_t user_node - = attribute_store_get_node_child_by_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - REPORTED_ATTRIBUTE, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - // If it exists we interview it again - if (attribute_store_node_exists(user_node)) { - sl_log_debug( - LOG_TAG, - "User Unique ID %d found. Undefine its reported value to update it.", - user_id); - attribute_store_set_desired(user_node, &user_id, sizeof(user_id)); - attribute_store_undefine_reported(user_node); - return; - } - } - - // If user id is 0 or not existant we create it - sl_log_debug(LOG_TAG, "Creating User Unique ID node %d", user_id); - attribute_store_emplace_desired(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); -} - static sl_status_t zwave_command_class_user_credential_user_set( attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { @@ -3260,72 +3215,65 @@ sl_status_t ///////////////////////////////////////////////////////////////////////////// // Post interview actions ///////////////////////////////////////////////////////////////////////////// -void zwave_network_status_changed(attribute_store_node_t updated_node, +void zwave_network_status_changed(attribute_store_node_t node, attribute_store_change_t change) { - attribute_store_node_t node_id_node - = attribute_store_get_first_parent_with_type(updated_node, - ATTRIBUTE_NODE_ID); + // We englobe this in case we can't read an attribute or something goes wrong + try { + attribute_store::attribute network_status_node(node); + auto node_id_node = network_status_node.first_parent(ATTRIBUTE_NODE_ID); - zwave_node_id_t node_id; - attribute_store_get_reported(node_id_node, &node_id, sizeof(node_id)); + // Should not happen but we check anyway to prevent an exception to raise + if (!node_id_node.reported_exists()) { + return; + } - // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything - if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { - return; - } + auto node_id = node_id_node.reported(); - NodeStateNetworkStatus network_status; - sl_status_t reported_value_status - = attribute_store_get_reported(updated_node, - &network_status, - sizeof(network_status)); + // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything + if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { + return; + } - // If the endpoint report is marked as ONLINE_FUNCTIONAL - if (reported_value_status == SL_STATUS_OK - && network_status == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { - sl_log_debug(LOG_TAG, - "Node %d is now ONLINE_FUNCTIONAL : start the delayed " - "interview process", - node_id); - // Perform action on each endpoint that supports User Credential Command class - uint8_t endpoint_count - = attribute_store_get_node_child_count_by_type(node_id_node, - ATTRIBUTE_ENDPOINT_ID); - - sl_log_debug(LOG_TAG, "Checking endpoints (total : %d)...", endpoint_count); - - for (uint8_t i = 0; i < endpoint_count; i++) { - // Get current endpoint node - attribute_store_node_t endpoint_node - = attribute_store_get_node_child_by_type(node_id_node, - ATTRIBUTE_ENDPOINT_ID, - i); - - zwave_endpoint_id_t endpoint_id; - attribute_store_get_reported(endpoint_node, - &endpoint_id, - sizeof(endpoint_id)); - // Check if the endpoint supports User Credential Command class - if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, - node_id, - endpoint_id)) { - auto user_count = attribute_store_get_node_child_count_by_type( - endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID)); - sl_log_debug(LOG_TAG, - "Endpoint %d supports User Credential.", - endpoint_id); - if (user_count == 0) { + // If the endpoint report is marked as ONLINE_FUNCTIONAL + if (network_status_node.reported() + == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { + sl_log_debug(LOG_TAG, + "Node %d is now ONLINE_FUNCTIONAL : start the delayed " + "interview process", + node_id); + // Perform action on each endpoint that supports User Credential Command class + sl_log_debug(LOG_TAG, "Checking endpoints..."); + for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { + auto endpoint_id = endpoint_node.reported(); + // Check if the endpoint supports User Credential Command class + if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, + node_id, + endpoint_id)) { sl_log_debug(LOG_TAG, - "No user found. Starting User and Credential interview"); - // Start the interview process with user ID = 0 - trigger_get_user(endpoint_node, 0); - } else { - sl_log_debug(LOG_TAG, "Users already discovered. No actions needed."); + "Endpoint %d supports User Credential.", + endpoint_id); + auto user_count + = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + if (user_count == 0) { + sl_log_debug( + LOG_TAG, + "No user found. Starting User and Credential interview"); + // Start the interview process with user ID = 0 + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(0); + } else { + sl_log_debug(LOG_TAG, + "Users already discovered. No actions needed."); + } } } + sl_log_debug(LOG_TAG, "Done."); } + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while handling network status change : %s", + e.what()); } } From f7ab712d087a8c2aaccc0503db34986a0c517fce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 29 Aug 2024 14:44:44 +0200 Subject: [PATCH 33/60] UIC-3222: Refactor User Credential Server We don't use desired state for credential type anymore since it's add complexity without any needs for it. --- .../user_credential_cluster_server_test.cpp | 4 +- .../zwave_command_class_user_credential.cpp | 679 +++++++----------- ...ave_command_class_user_credential_test.cpp | 10 +- 3 files changed, 262 insertions(+), 431 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index 366d94dc3..bc316c16d 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -947,7 +947,7 @@ void helper_test_desired_credential_attributes( ATTRIBUTE(CREDENTIAL_TYPE)); user_credential_type_t reported_credential_type; attribute_store_read_value(credential_type_node, - credential_identifier_state, + REPORTED_ATTRIBUTE, &reported_credential_type, sizeof(reported_credential_type)); TEST_ASSERT_EQUAL_MESSAGE(credential_type, @@ -2047,7 +2047,7 @@ void test_user_credential_cluster_learn_start_add_happy_case() auto credential_type_node = attribute_store_get_node_child_by_value(user_id_node, ATTRIBUTE(CREDENTIAL_TYPE), - DESIRED_ATTRIBUTE, + REPORTED_ATTRIBUTE, (uint8_t *)&credential_type, sizeof(credential_type), 0); diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index b05a64927..a24095b9d 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -19,7 +19,6 @@ #include "zwave_command_classes_utils.h" #include "ZW_classcmd.h" - // Includes from other ZPC Components #include "zwave_command_class_indices.h" #include "zwave_command_handler.h" @@ -67,7 +66,7 @@ constexpr uint8_t MAX_CHAR_SIZE = 64; constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; // Using -using attribute_callback = std::function; +using attribute_callback = std::function; /** * @brief Implementation notes @@ -723,8 +722,9 @@ attribute_store::attribute if (!cred_slot_node.is_valid()) { throw std::runtime_error( (boost::format( - "Credential type %1% (state : %2%) not found for %3% / %4%.") - % cred_slot % state % cred_type_node.value_to_string()) + "Credential slot %1% (state : %2%) not found for %3% / %4%.") + % cred_slot % state % cred_type_node.value_to_string() + % cred_type_node.parent().value_to_string()) .str()); } @@ -841,7 +841,8 @@ void for_each_credential_type_nodes_for_user( const attribute_callback &callback, user_credential_type_t credential_type = 0) { - auto credential_type_nodes = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); + auto credential_type_nodes + = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); for (auto &credential_type_node: credential_type_nodes) { // Call if (credential_type == 0 @@ -872,8 +873,6 @@ void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, } } - - /** * @brief Get credential slot node * @@ -1623,10 +1622,9 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( * @param credential_slot 0 to get the first credential; valid value otherwise * */ -void trigger_get_credential( - attribute_store::attribute &user_unique_id_node, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) +void trigger_get_credential(attribute_store::attribute &user_unique_id_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) { sl_log_debug(LOG_TAG, "Trigger GET credential for user %d : " @@ -1827,7 +1825,6 @@ sl_status_t return SL_STATUS_OK; } - sl_status_t zwave_command_class_user_credential_credential_handle_report( const zwave_controller_connection_info_t *connection_info, const uint8_t *frame_data, @@ -1898,8 +1895,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( credential_type); credential_slot_node = create_or_update_desired_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot); + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); } break; case credential_report_type_t::CREDENTIAL_MODIFIED: { @@ -3495,37 +3492,33 @@ sl_status_t zwave_command_class_user_credential_modify_user( * @param credential_type Credential type * @param credential_data_vector Vector to store the converted data * - * @return SL_STATUS_OK if the conversion was successful, SL_STATUS_FAIL otherwise + * @throws std::runtime_error if the credential data is invalid + * + * @return The converted data */ -sl_status_t get_credential_data(const char *credential_data, - user_credential_type_t credential_type, - std::vector &credential_data_vector) +std::vector + convert_credential_data(const char *credential_data, + user_credential_type_t credential_type) { + std::vector credential_data_vector; std::string credential_data_str(credential_data); switch (credential_type) { case CREDENTIAL_REPORT_PASSWORD: { // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order - try { - auto credential_data_utf16 = utf8_to_utf16(credential_data_str); - for (const auto &c: credential_data_utf16) { - credential_data_vector.push_back((uint8_t)(c >> 8)); - credential_data_vector.push_back((uint8_t)c); - } - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while converting credential data to UTF16: %s", - e.what()); - return SL_STATUS_FAIL; + auto credential_data_utf16 = utf8_to_utf16(credential_data_str); + for (const auto &c: credential_data_utf16) { + credential_data_vector.push_back((uint8_t)(c >> 8)); + credential_data_vector.push_back((uint8_t)c); } } break; case CREDENTIAL_REPORT_PIN_CODE: for (const auto &c: credential_data_str) { if (c < '0' || c > '9') { - sl_log_error(LOG_TAG, - "Invalid character in PIN code: %c. Only digits are " - "allowed.", - c); - return SL_STATUS_FAIL; + throw std::runtime_error( + (boost::format( + "Invalid character in PIN code : %1%. Only digits are allowed.") + % c) + .str()); } credential_data_vector.push_back(c); } @@ -3536,7 +3529,26 @@ sl_status_t get_credential_data(const char *credential_data, } } - return SL_STATUS_OK; + return credential_data_vector; +} + +std::vector + validate_credential_data(credential_capabilities &capabilities, + const char *credential_data, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + std::vector credential_data_vector + = convert_credential_data(credential_data, credential_type); + + // Credential not valid, we are not adding it + if (!capabilities.is_credential_valid(credential_type, + credential_slot, + credential_data_vector)) { + throw std::runtime_error("Credential capabilities are not valid."); + } + + return credential_data_vector; } sl_status_t zwave_command_class_user_credential_add_new_credential( @@ -3546,6 +3558,15 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( user_credential_slot_t credential_slot, const char *credential_data) { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + // Check if parameters are ok if (credential_type == 0 || credential_slot == 0) { sl_log_error( @@ -3566,10 +3587,6 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - // Create or update existing structure - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - if (!is_credential_available(endpoint_node, credential_type, credential_slot)) { @@ -3581,66 +3598,36 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( return SL_STATUS_FAIL; } - attribute_store::attribute user_id_node; try { - user_id_node = get_reported_user_id_node(endpoint_node, user_id); + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Get or create credential type node + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + + // Process credential data + std::vector credential_data_vector + = validate_credential_data(capabilities, + credential_data, + credential_type, + credential_slot); + + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector, + DESIRED_ATTRIBUTE); + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't find User %d. Not adding credentials.", - user_id); - return SL_STATUS_FAIL; - } - - // Get or create credential type node - credential_type_node - = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); - - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_add_new_credential called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - - // Process credential data - std::vector credential_data_vector; - sl_status_t credential_data_conversion_status - = get_credential_data(credential_data, - credential_type, - credential_data_vector); - // Something went wrong, we need to delete the slot - if (credential_data_conversion_status == SL_STATUS_FAIL) { - return SL_STATUS_FAIL; - } - - if (!capabilities.is_credential_valid(credential_type, - credential_slot, - credential_data_vector)) { - sl_log_error( - LOG_TAG, - "Credential capabilities are not valid. Not adding credential."); + "Error while trying to add a new credential : %s", + e.what()); return SL_STATUS_FAIL; } - // Create credential slot - credential_slot_node - = attribute_store_emplace_desired(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); - - // Add data - attribute_store_emplace_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - credential_data_vector.data(), - credential_data_vector.size()); - - // Finally set operation type add - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); - return SL_STATUS_OK; } @@ -3651,40 +3638,6 @@ sl_status_t zwave_command_class_user_credential_modify_credential( user_credential_slot_t credential_slot, const char *credential_data) { - // Get credential structure - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - - // First check Credential Type existence - bool node_found = get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - if (!node_found) { - sl_log_error( - LOG_TAG, - "Can't find Credential Type %d for User %d. Not modifing credentials.", - credential_type, - user_id); - return SL_STATUS_FAIL; - } - - node_found = get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - - if (!node_found) { - sl_log_error(LOG_TAG, - "Can't find Credential Slot %d for Credential Type %d (User " - "%d). Not modifing credentials.", - credential_slot, - credential_type, - user_id); - return SL_STATUS_FAIL; - } - // Debug info sl_log_debug( LOG_TAG, @@ -3694,49 +3647,45 @@ sl_status_t zwave_command_class_user_credential_modify_credential( sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - // Process credential data - std::vector credential_data_vector; - sl_status_t credential_data_conversion_status - = get_credential_data(credential_data, - credential_type, - credential_data_vector); - // Something went wrong, we don't modify - if (credential_data_conversion_status == SL_STATUS_FAIL) { + // Check if parameters are ok + if (user_id == 0 || credential_type == 0 || credential_slot == 0) { sl_log_error(LOG_TAG, - "Something went wrong while processing credential data. Not " + "User ID, Credential Type and Slot 0 are reserved. Not " "modifying credentials."); return SL_STATUS_FAIL; } - // Verify credential validity - auto capabilities - = get_credential_capabilities(endpoint_node, credential_type); - if (!capabilities.is_credential_valid(credential_type, - credential_slot, - credential_data_vector)) { - sl_log_error( - LOG_TAG, - "Credential capabilities are not valid. Not adding credential."); - return SL_STATUS_FAIL; - } + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + // Get current credential slot node + auto credential_slot_node = nodes.slot_node; + // Process credential data + auto capabilities + = get_credential_capabilities(endpoint_node, credential_type); + std::vector credential_data_vector + = validate_credential_data(capabilities, + credential_data, + credential_type, + credential_slot); + // Modify current data + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) + .set_desired(credential_data_vector); + + // Finally set operation type modify + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - // Add data - sl_status_t status - = attribute_store_set_child_desired(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA), - credential_data_vector.data(), - credential_data_vector.size()); - if (status != SL_STATUS_OK) { + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't set CREDENTIAL_DATA in attribute store. Not modifying " - "credential."); + "Error while trying to modify a credential : %s", + e.what()); return SL_STATUS_FAIL; } - // Finally set operation type modify - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - return SL_STATUS_OK; } @@ -3746,70 +3695,39 @@ sl_status_t zwave_command_class_user_credential_delete_credential( user_credential_type_t credential_type, user_credential_slot_t credential_slot) { - // First see if the user exists - auto user_id_node = get_reported_user_id_node(endpoint_node, user_id); - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "Can't find user with ID %d. Not adding credentials.", - user_id); - return SL_STATUS_FAIL; - } - - // Get credential structure - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - - // First check Credential Type existence - bool node_found = get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - if (!node_found) { - sl_log_error( - LOG_TAG, - "Can't find Credential Type %d for User %d. Not deleting credentials.", - credential_type, - user_id); - return SL_STATUS_FAIL; - } - - node_found = get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - - if (!node_found) { - sl_log_error(LOG_TAG, - "Can't find Credential Slot %d for Credential Type %d (User " - "%d). Not deleting credentials.", - credential_slot, - credential_type, - user_id); - return SL_STATUS_FAIL; - } - - // Finally set operation type delete - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); sl_log_debug(LOG_TAG, "Delete credential slot %d (credential type %d, user id %d)", credential_slot, credential_type, user_id); + + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + // Finally set operation type delete + set_credential_operation_type(nodes.slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to delete a credential : %s", + e.what()); + return SL_STATUS_FAIL; + } + return SL_STATUS_OK; } sl_status_t zwave_command_class_user_credential_delete_all_users( attribute_store_node_t endpoint_node) { - // Send an User SET with user id = 0 + attribute_store::attribute cpp_endpoint_node(endpoint_node); user_credential_user_unique_id_t user_id = 0; - attribute_store_node_t user_id_node - = attribute_store_emplace(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); + auto user_id_node + = cpp_endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Finally set operation type delete set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); @@ -3821,26 +3739,15 @@ sl_status_t zwave_command_class_user_credential_delete_all_users( return SL_STATUS_OK; } -void trigger_credential_deletion(attribute_store_node_t endpoint_node, +void trigger_credential_deletion(attribute_store::attribute endpoint_node, user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot) { - attribute_store_node_t user_id_node - = attribute_store_emplace(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - attribute_store_node_t credential_type_node - = attribute_store_emplace(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - attribute_store_node_t credential_slot_node - = attribute_store_emplace(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); + auto credential_slot_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id) + .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type) + .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), credential_slot); // Finally set operation type delete set_credential_operation_type(credential_slot_node, @@ -3913,6 +3820,18 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( user_credential_slot_t credential_slot, user_credential_learn_timeout_t credential_learn_timeout) { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (Add)" + " called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + auto credential_capabilities = get_credential_capabilities(endpoint_node, credential_type); @@ -3941,10 +3860,6 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( return SL_STATUS_FAIL; } - // Create or update existing structure - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - if (!is_credential_available(endpoint_node, credential_type, credential_slot)) { @@ -3956,56 +3871,37 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( return SL_STATUS_FAIL; } - // Get or add credential type node - credential_type_node = add_credential_type_node_if_missing(endpoint_node, - user_id, - credential_type); - - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_error(LOG_TAG, - "Can't find Credential Type %d for User %d. Not adding " - "credentials.", - credential_type, - user_id); - return SL_STATUS_FAIL; - } - - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (Add)" - " called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); - if (credential_learn_timeout == 0) { - credential_learn_timeout - = credential_capabilities.learn_recommended_timeout; - sl_log_debug(LOG_TAG, - "Credential learn timeout is 0. Setting it to default " - "reported value (%d seconds).", - credential_learn_timeout); - } + // Create credential slot with reported value since we don't want + // to trigger a Credential Get right away + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); - // Create credential slot with reported value since we don't want - // to trigger a Credential Get right away - credential_slot_node = attribute_store_emplace(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &credential_slot, - sizeof(credential_slot)); + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.learn_recommended_timeout; + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } - // Set attributes for Credential Learn - attribute_store_set_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), - &credential_learn_timeout, - sizeof(credential_learn_timeout)); + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); - set_credential_learn_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error in credential learn start : %s", e.what()); + return SL_STATUS_FAIL; + } return SL_STATUS_OK; } @@ -4017,6 +3913,18 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( user_credential_slot_t credential_slot, user_credential_learn_timeout_t credential_learn_timeout) { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (modify) " + "called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + auto credential_capabilities = get_credential_capabilities(endpoint_node, credential_type); @@ -4036,42 +3944,6 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( return SL_STATUS_FAIL; } - // Get current structure - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - attribute_store_node_t credential_slot_node = ATTRIBUTE_STORE_INVALID_NODE; - - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - get_credential_slot_node(credential_type_node, - credential_slot, - REPORTED_ATTRIBUTE, - credential_slot_node); - - if (!attribute_store_node_exists(credential_type_node) - || !attribute_store_node_exists(credential_slot_node)) { - sl_log_error(LOG_TAG, - "Can't find Credential Type %d for User %d. Not adding " - "credentials.", - credential_type, - user_id); - return SL_STATUS_FAIL; - } - - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (modify) " - "called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); - if (credential_learn_timeout == 0) { credential_learn_timeout = credential_capabilities.learn_recommended_timeout; @@ -4081,14 +3953,26 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( credential_learn_timeout); } - // Set attributes for Credential Learn - attribute_store_set_child_reported(credential_slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT), - &credential_learn_timeout, - sizeof(credential_learn_timeout)); - - set_credential_learn_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + auto credential_slot_node = nodes.slot_node; + + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error in credential learn start modify : %s", + e.what()); + return SL_STATUS_FAIL; + } return SL_STATUS_OK; } @@ -4112,62 +3996,28 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( user_credential_user_unique_id_t destination_user_id, user_credential_slot_t destination_credential_slot) { - attribute_store_node_t source_user_id_node; - bool user_exists = get_user_id_node(endpoint_node, - source_user_id, - REPORTED_ATTRIBUTE, - source_user_id_node); - if (!user_exists) { - sl_log_error( - LOG_TAG, - "Can't find source user with ID %d. Not adding uuic association set.", - source_user_id); - return SL_STATUS_FAIL; - } - - attribute_store_node_t credential_type_node; - bool cred_type_exists = get_credential_type_node(endpoint_node, - source_user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - - if (!cred_type_exists) { - sl_log_error(LOG_TAG, - "Can't find credential type %d for user %d. Not adding uuic " - "association set.", - credential_type, - source_user_id); - return SL_STATUS_FAIL; - } - attribute_store_node_t source_credential_slot_node; - bool cred_slot_exists = get_credential_slot_node(credential_type_node, - source_credential_slot, - REPORTED_ATTRIBUTE, - source_credential_slot_node); - - if (!cred_slot_exists) { + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {source_user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {source_credential_slot, REPORTED_ATTRIBUTE}); + + nodes.slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)) + .set_desired(destination_user_id); + + // Slot ID last since it's this attribute that is bound to the SET command + nodes.slot_node + .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) + .set_desired(destination_credential_slot); + } catch (std::exception& e) { sl_log_error(LOG_TAG, - "Can't find source credential slot %d for credential type %d. " - "Not adding uuic association set.", - source_credential_slot, - credential_type); + "Error while setting up uuic asociation set : %s", + e.what()); return SL_STATUS_FAIL; } - attribute_store_emplace_desired(source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), - &destination_user_id, - sizeof(destination_user_id)); - - // Slot ID last since it's this attribute that is bound to the SET command - attribute_store_emplace_desired( - source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), - &destination_credential_slot, - sizeof(destination_credential_slot)); - return SL_STATUS_OK; } @@ -4175,29 +4025,19 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id) { - attribute_store_node_t user_id_node; - bool user_exists = get_user_id_node(endpoint_node, - user_id, - REPORTED_ATTRIBUTE, - user_id_node); - if (!user_exists) { - sl_log_error( - LOG_TAG, - "Can't find source user with ID %d. Not setting up User Checksum Get.", - user_id_node); - return SL_STATUS_FAIL; - } - - auto checksum_node - = attribute_store_get_first_child_by_type(user_id_node, - ATTRIBUTE(USER_CHECKSUM)); + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - // If node already exists, we clear its value to trigger the GET - if (attribute_store_node_exists(checksum_node)) { - attribute_store_undefine_reported(checksum_node); - attribute_store_undefine_desired(checksum_node); - } else { - attribute_store_add_node(ATTRIBUTE(USER_CHECKSUM), user_id_node); + auto checksum_node = user_id_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch(const std::exception& e) { + sl_log_error(LOG_TAG, + "Error while setting up user get checksum : %s", + e.what()); + return SL_STATUS_FAIL; } return SL_STATUS_OK; @@ -4206,34 +4046,31 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( sl_status_t zwave_command_class_user_credential_get_credential_checksum( attribute_store_node_t endpoint_node, user_credential_type_t credential_type) { - attribute_store_node_t supported_credential_type_node - = attribute_store_get_node_child_by_value( - endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - REPORTED_ATTRIBUTE, - &credential_type, - sizeof(credential_type), - 0); - - if (!attribute_store_node_exists(supported_credential_type_node)) { - sl_log_error( - LOG_TAG, - "Can't find supported credential type %d. Not setting up Checksum get.", - credential_type); - return SL_STATUS_FAIL; - } + try { + attribute_store::attribute cpp_endpoint_node(endpoint_node); + auto supported_credential_type_node + = cpp_endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); - auto checksum_node - = attribute_store_get_first_child_by_type(supported_credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM)); + if (!supported_credential_type_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Can't find supported credential type %d. Not setting up Checksum get.", + credential_type); + return SL_STATUS_FAIL; + } - // If node already exists, we clear its value to trigger the GET - if (attribute_store_node_exists(checksum_node)) { - attribute_store_undefine_reported(checksum_node); - attribute_store_undefine_desired(checksum_node); - } else { - attribute_store_add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM), - supported_credential_type_node); + auto checksum_node + = supported_credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up credential get checksum : %s", + e.what()); + return SL_STATUS_FAIL; } return SL_STATUS_OK; diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 84e3e2a3a..d1892a100 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -297,15 +297,10 @@ void helper_test_credential_learn_structure( credential_slot_node, DESIRED_ATTRIBUTE); - auto credential_type_state - = expected_operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD - ? DESIRED_ATTRIBUTE - : REPORTED_ATTRIBUTE; - user_credential_user_unique_id_t user_id = user_id_node.reported(); user_credential_type_t credential_type - = credential_type_node.get(credential_type_state); + = credential_type_node.reported(); user_credential_slot_t credential_slot = credential_slot_node.reported(); @@ -2820,8 +2815,7 @@ void test_user_credential_credential_learn_start_add_happy_case() auto update_credential_nodes = [&]() { credential_type_node = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), - credential_type, - DESIRED_ATTRIBUTE); + credential_type); credential_slot_node = credential_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), From d480ef940e9dcf28c3d236716d8b29f2f8494b9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Fri, 30 Aug 2024 13:04:09 +0200 Subject: [PATCH 34/60] UIC-3222: Remove unused structs and function --- .../zwave_command_class_user_credential.cpp | 84 +------------------ 1 file changed, 1 insertion(+), 83 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index a24095b9d..cb745ecfc 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -87,31 +87,7 @@ zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); ///////////////////////////////////////////////////////////////////////////// // Data struct ///////////////////////////////////////////////////////////////////////////// - -struct uint16_exploded { - uint8_t msb; // Most Significant Bit - uint8_t lsb; // Less Significant Bit -}; - -// Used to define reported values -struct user_field_data { - attribute_store_type_t node_type; - uint8_t report_index; - uint8_t bitmask = 0; - uint8_t shift_right = 0; -}; - -// Used to create command frame -struct attribute_command_data { - // Attribute type that will be fetched from the base_node - attribute_store_type_t attribute_type; - // Attribute value state (reported, desired,...) - attribute_store_node_value_state_t attribute_state; - // If not ATTRIBUTE_STORE_INVALID_NODE, the function will not fetch attribute_type - // but will use this node directly - attribute_store_node_t node = ATTRIBUTE_STORE_INVALID_NODE; -}; - +// Represent a credential ID (slot, type, user unique ID) struct credential_id_nodes { attribute_store::attribute slot_node; attribute_store::attribute type_node; @@ -1083,64 +1059,6 @@ credential_id_nodes get_credential_identifier_nodes( // Attributes helpers ///////////////////////////////////////////////////////////////////////////// -/** @brief Set reported attributes based on user_data - * - * @note This function also undefine all desired values - * - * @param base_node Parent node of the newly created attributes - * @param frame_data Frame data to interpret - * @param user_data User data to interpret frame_data - * - * @return sl_status_t SL_STATUS_OK if everything was fine -*/ -sl_status_t - set_reported_attributes(attribute_store_node_t base_node, - const uint8_t *frame_data, - const std::vector &user_data) -{ - sl_status_t status = SL_STATUS_OK; - - for (const auto &field: user_data) { - attribute_store_storage_type_t storage_type - = attribute_store_get_storage_type(field.node_type); - - switch (storage_type) { - case U8_STORAGE_TYPE: { - uint8_t uint8_value = frame_data[field.report_index]; - if (field.bitmask != 0) { - uint8_value = (uint8_value & field.bitmask) >> field.shift_right; - } - status |= attribute_store_set_child_reported(base_node, - field.node_type, - &uint8_value, - sizeof(uint8_value)); - } break; - // Unsigned 16-bit integers are used for this attribute - case U16_STORAGE_TYPE: { - uint16_t uint16_value - = get_uint16_value(frame_data, field.report_index); - status |= attribute_store_set_child_reported(base_node, - field.node_type, - &uint16_value, - sizeof(uint16_value)); - - break; - } - default: - sl_log_error(LOG_TAG, - "Internal error : unsupported storage_type in " - "set_reported_attributes"); - return SL_STATUS_NOT_SUPPORTED; - } - - // Undefined desired value - status - |= attribute_store_set_child_desired(base_node, field.node_type, NULL, 0); - } - - return status; -} - /** * @brief Get value inside the node and store it in a uint8_t vector * From 30eb0ffdd29db6c5ff5e8de8afddea2b2bfefbb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 2 Sep 2024 11:10:07 +0200 Subject: [PATCH 35/60] UIC-3222: Move User/Credential capabilities into their own file This will make the User Credential Implementation clearer --- .../zwave_command_classes/CMakeLists.txt | 5 +- ...ser_credential_credential_capabilities.cpp | 212 +++++++++ .../user_credential_credential_capabilities.h | 94 ++++ .../user_credential_user_capabilities.cpp | 121 +++++ .../user_credential_user_capabilities.h | 104 +++++ .../zwave_command_class_user_credential.cpp | 428 +----------------- 6 files changed, 551 insertions(+), 413 deletions(-) create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h diff --git a/applications/zpc/components/zwave_command_classes/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/CMakeLists.txt index c1ee84ed2..c338ae9da 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -64,7 +64,10 @@ add_library( src/zwave_command_classes_utils.c src/zwave_command_class_inclusion_controller.cpp src/zwave_command_class_transport_service.c - src/zwave_command_class_protocol.c) + src/zwave_command_class_protocol.c + src/private/user_credential/user_credential_user_capabilities.cpp + src/private/user_credential/user_credential_credential_capabilities.cpp +) install(TARGETS zwave_command_classes LIBRARY DESTINATION lib) target_include_directories( diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp new file mode 100644 index 000000000..024f8c84b --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp @@ -0,0 +1,212 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#include "user_credential_credential_capabilities.h" + +// Get attribute store names +#include "attribute_store_defined_attribute_types.h" + +// Log +#include "sl_log.h" + +// UTF16 conversion (deprecated in C++17 but we don't have a better alternative yet) +// Needed for credential data (password) per specification +#include +#include + +// Boost +#include + +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +namespace user_credential +{ + +constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; + +credential_capabilities::credential_capabilities( + const attribute_store::attribute &endpoint_node, + user_credential_type_t credential_type) +{ + this->is_data_valid = false; + + try { + auto supported_credential_type_node = endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + + if (!supported_credential_type_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Credential type %d not supported. Can't get capabilities for it.", + credential_type); + return; + } + + this->max_slot_count + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT)) + .reported(); + this->learn_support = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT)) + .reported(); + this->min_credential_length + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_MIN_LENGTH)) + .reported(); + this->max_credential_length + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_MAX_LENGTH)) + .reported(); + this->learn_recommended_timeout + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)) + .reported(); + this->learn_number_of_steps + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS)) + .reported(); + + this->credential_type = credential_type; + this->is_data_valid = true; + } catch (std::exception &e) { + sl_log_error(LOG_TAG, + "Something was wrong getting credential capabilities : %s", + e.what()); + } +} + +bool credential_capabilities::is_learn_supported() const +{ + return is_data_valid && learn_support > 0; +} + +bool credential_capabilities::is_credential_valid( + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::vector &credential_data) const +{ + if (!is_data_valid) { + sl_log_error( + LOG_TAG, + "Credential capabilities are not valid. Try restarting the device."); + return false; + } + + if (credential_type != this->credential_type) { + sl_log_error(LOG_TAG, "Credential type mismatch."); + return false; + } + + if (!is_slot_valid(credential_slot)) { + sl_log_error( + LOG_TAG, + "Slot ID is not valid. Given : %d, Max Supported Slot count : %d", + credential_slot, + max_slot_count); + return false; + } + + if (!is_credential_data_valid(credential_data)) { + sl_log_error(LOG_TAG, + "Credential data size is not valid. Should be between %d " + "and %d, given : %d", + min_credential_length, + max_credential_length, + credential_data.size()); + return false; + } + + return true; +} + +bool credential_capabilities::is_slot_valid( + user_credential_slot_t credential_slot) const +{ + return credential_slot <= max_slot_count; +} + +bool credential_capabilities::is_credential_data_valid( + const std::vector &credential_data) const +{ + return (credential_data.size() >= min_credential_length + && credential_data.size() <= max_credential_length); +} + +std::vector + credential_capabilities::convert_and_validate_credential_data( + const char *credential_data, user_credential_slot_t credential_slot) const +{ + std::vector credential_data_vector + = convert_credential_data(credential_data); + + // Credential not valid, we are not adding it + if (!this->is_credential_valid(this->credential_type, + credential_slot, + credential_data_vector)) { + throw std::runtime_error("Credential capabilities are not valid."); + } + + return credential_data_vector; +} + +std::vector + credential_capabilities::convert_credential_data(const char *credential_data) const +{ + std::vector credential_data_vector; + std::string credential_data_str(credential_data); + switch (credential_type) { + case CREDENTIAL_REPORT_PASSWORD: { + // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + auto credential_data_utf16 = utf8_to_utf16(credential_data_str); + for (const auto &c: credential_data_utf16) { + credential_data_vector.push_back((uint8_t)(c >> 8)); + credential_data_vector.push_back((uint8_t)c); + } + } break; + case CREDENTIAL_REPORT_PIN_CODE: + for (const auto &c: credential_data_str) { + if (c < '0' || c > '9') { + throw std::runtime_error( + (boost::format("Invalid character in PIN code : %1%. Only digits " + "are allowed.") + % c) + .str()); + } + credential_data_vector.push_back(c); + } + break; + default: + for (const auto &c: credential_data_str) { + credential_data_vector.push_back(c); + } + } + + return credential_data_vector; +} + +uint8_t credential_capabilities::get_learn_recommended_timeout() const +{ + return learn_recommended_timeout; +} + +std::u16string credential_capabilities::utf8_to_utf16(const std::string &utf8) const +{ + std::wstring_convert, char16_t> cnv; + std::u16string s = cnv.from_bytes(utf8); + if (cnv.converted() < utf8.size()) + throw std::runtime_error("Something went wrong converting UTF8 to UTF16"); + return s; +} + +} // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h new file mode 100644 index 000000000..fe2c354a3 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h @@ -0,0 +1,94 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#ifndef USER_CREDENTIAL_CREDENTIAL_CAPABILITIES_H +#define USER_CREDENTIAL_CREDENTIAL_CAPABILITIES_H + +// Cpp definitions +#include +#include + +// Attribute store +#include "attribute.hpp" +// User credential types +#include "zwave_command_class_user_credential_types.h" + +namespace user_credential +{ + +class credential_capabilities +{ + public: + explicit credential_capabilities( + const attribute_store::attribute &endpoint_node, + user_credential_type_t credential_type); + ~credential_capabilities() = default; + + bool is_learn_supported() const; + + bool is_credential_valid(user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::vector &credential_data) const; + + bool is_slot_valid(user_credential_slot_t credential_slot) const; + bool + is_credential_data_valid(const std::vector &credential_data) const; + + /** + * @brief Convert and validate credential data str to a vector of uint8_t + * + * Convenience function to convert data and check if it is valid as per the credential capabilities. + * + * @param credential_data Credential data to convert + * @param credential_slot Credential slot + * + * @throws std::runtime_error if the credential data is invalid + * + * @return The converted data + */ + std::vector convert_and_validate_credential_data( + const char *credential_data, user_credential_slot_t credential_slot) const; + + /** + * @brief Convert credential data str to a vector of uint8_t + * + * @note CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + * + * @param credential_data Credential data to convert + * + * @throws std::runtime_error if the credential data is invalid + * + * @return The converted data +*/ + std::vector convert_credential_data(const char *credential_data) const; + + uint8_t get_learn_recommended_timeout() const; + + private: + + std::u16string utf8_to_utf16(const std::string &utf8) const; + + user_credential_type_t credential_type = 0; + uint16_t max_slot_count = 0; + uint8_t learn_support = 0; + uint8_t min_credential_length = 0; + uint8_t max_credential_length = 0; + uint8_t learn_recommended_timeout = 0; + uint8_t learn_number_of_steps = 0; + + bool is_data_valid = false; +}; + +} // namespace user_credential + +#endif // USER_CREDENTIAL_CREDENTIAL_CAPABILITIES_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp new file mode 100644 index 000000000..19bedddd9 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp @@ -0,0 +1,121 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#include "user_credential_user_capabilities.h" + +// Get attribute store names +#include "attribute_store_defined_attribute_types.h" + +// Log +#include "sl_log.h" + +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type + +namespace user_credential +{ + +constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; + +user_capabilities::user_capabilities(attribute_store::attribute endpoint_node) { + try { + this->max_user_count + = endpoint_node.child_by_type(ATTRIBUTE(NUMBER_OF_USERS)) + .reported(); + this->supported_credential_rules_bitmask + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES)) + .reported(); + this->supported_user_types_bitmask + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORTED_USER_TYPES)) + .reported(); + this->max_user_name_length + = endpoint_node.child_by_type(ATTRIBUTE(MAX_USERNAME_LENGTH)) + .reported(); + this->support_user_schedule + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_USER_SCHEDULE)) + .reported(); + this->support_all_user_checksum + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM)) + .reported(); + this->support_by_user_checksum + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_USER_CHECKSUM)) + .reported(); + + + this->is_data_valid = true; + } catch (std::exception &e) { + sl_log_error(LOG_TAG, + "Something was wrong getting user capabilities : %s", + e.what()); + this->is_data_valid = false; + } +} + + +bool user_capabilities::is_user_valid(user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + const char *user_name) const +{ + if (!is_data_valid) { + sl_log_error(LOG_TAG, + "User capabilities are not valid. Try restarting the device."); + return false; + } + + if (!is_user_id_valid(user_id)) { + sl_log_error(LOG_TAG, "User ID is not valid."); + return false; + } + + if (!is_user_type_supported(user_type)) { + sl_log_error(LOG_TAG, "User type is not supported."); + return false; + } + + if (!is_credential_rule_supported(credential_rule)) { + sl_log_error(LOG_TAG, "Credential rule is not supported."); + return false; + } + + if (!is_user_name_valid(user_name)) { + sl_log_error(LOG_TAG, "User name is not valid."); + return false; + } + return true; +} + +bool user_capabilities::is_user_name_valid(const char *user_name) const +{ + std::string str_user_name(user_name); + return str_user_name.length() <= max_user_name_length; +} + +bool user_capabilities::is_user_id_valid( + user_credential_user_unique_id_t user_id) const +{ + return user_id <= max_user_count; +} + +bool user_capabilities::is_user_type_supported( + user_credential_type_t user_type) const +{ + return (supported_user_types_bitmask & (1 << user_type)); +} + +bool user_capabilities::is_credential_rule_supported( + user_credential_rule_t credential_rule) const +{ + return (supported_credential_rules_bitmask & (1 << credential_rule)); +} + +} // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h new file mode 100644 index 000000000..be04fb393 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h @@ -0,0 +1,104 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#ifndef USER_CREDENTIAL_USER_CAPABILITIES_H +#define USER_CREDENTIAL_USER_CAPABILITIES_H + +// Attribute store +#include "attribute.hpp" +// User credential types +#include "zwave_command_class_user_credential_types.h" + + +namespace user_credential +{ + +class user_capabilities +{ + public: + explicit user_capabilities(attribute_store::attribute endpoint_node); + ~user_capabilities() = default; + + /** + * @brief Check if the user proprieties are valid + * + * @note Will return false if is_data_valid is false + * + * @param user_id User ID + * @param user_type User type + * @param credential_rule Credential rule + * @param user_name User name + * + * @return true User is valid + * @return false User is not valid + */ + bool is_user_valid(user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + const char *user_name) const; + + /** + * @brief Checks if the given user name is valid. + * @param user_name The user name to be validated. + * @return true User name is valid + * @return false User name is not valid + */ + bool is_user_name_valid(const char *user_name) const; + + /** + * @brief Check if a user id is valid + * @param user_id User ID to check + * @return true User ID is valid + * @return false User ID is not valid + */ + bool is_user_id_valid(user_credential_user_unique_id_t user_id) const; + /** + * @brief Check if a user type is supported + * @param user_type User type to check + * @return true User type is supported + * @return false User type is not supported + */ + bool is_user_type_supported(user_credential_type_t user_type) const; + + /** + * @brief Check if a credential rule is supported + * @param credential_rule Credential rule to check + * @return true Credential rule is supported + * @return false Credential rule is not supported + */ + bool + is_credential_rule_supported(user_credential_rule_t credential_rule) const; + + private: + // Maximum number of users that can be stored in the device + uint16_t max_user_count = 0; + // Credential rules supported + uint8_t supported_credential_rules_bitmask = 0; + // User types supported + uint32_t supported_user_types_bitmask = 0; + // Max length for the user names + uint8_t max_user_name_length = 0; + // Device support for scheduling users + uint8_t support_user_schedule = 0; + // Device support for getting the checksum of all users + uint8_t support_all_user_checksum = 0; + // Device support for getting the checksum of a specific user + uint8_t support_by_user_checksum = 0; + + // True if the data is valid inside this struct + bool is_data_valid = false; +}; + +} // namespace user_credential + +#endif // USER_CREDENTIAL_USER_CAPABILITIES_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index cb745ecfc..700983d48 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -48,10 +48,9 @@ #include "zwave_frame_generator.hpp" #include "zwave_frame_parser.hpp" -// UTF16 conversion (deprecated in C++17) -// Needed for credential data (password) per specification -#include -#include +// Private helpers +#include "private/user_credential/user_credential_user_capabilities.h" +#include "private/user_credential/user_credential_credential_capabilities.h" // Macro #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type @@ -94,319 +93,6 @@ struct credential_id_nodes { attribute_store::attribute user_unique_id_node; }; -///////////////////////////////////////////////////////////////////////////// -// Capabilites Data Structs -///////////////////////////////////////////////////////////////////////////// -// User capabilities -struct user_capabilities { - // Maximum number of users that can be stored in the device - uint16_t max_user_count = 0; - // Credential rules supported - uint8_t supported_credential_rules_bitmask = 0; - // User types supported - uint32_t supported_user_types_bitmask = 0; - // Max length for the user names - uint8_t max_user_name_length = 0; - // Device support for scheduling users - uint8_t support_user_schedule = 0; - // Device support for getting the checksum of all users - uint8_t support_all_user_checksum = 0; - // Device support for getting the checksum of a specific user - uint8_t support_by_user_checksum = 0; - - // True if the data is valid inside this struct - bool is_data_valid = false; - - /** - * @brief Check if the user proprieties are valid - * - * @note Will return false if is_data_valid is false - * - * @param user_id User ID - * @param user_type User type - * @param credential_rule Credential rule - * @param user_name User name - * - * @return true User is valid - * @return false User is not valid - */ - bool is_user_valid(user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - const char *user_name) - { - if (!is_data_valid) { - sl_log_error( - LOG_TAG, - "User capabilities are not valid. Try restarting the device."); - return false; - } - - if (!is_user_id_valid(user_id)) { - sl_log_error(LOG_TAG, "User ID is not valid."); - return false; - } - - if (!is_user_type_supported(user_type)) { - sl_log_error(LOG_TAG, "User type is not supported."); - return false; - } - - if (!is_credential_rule_supported(credential_rule)) { - sl_log_error(LOG_TAG, "Credential rule is not supported."); - return false; - } - - if (!is_user_name_valid(user_name)) { - sl_log_error(LOG_TAG, "User name is not valid."); - return false; - } - return true; - } - - /** - * @brief Checks if the given user name is valid. - * @param user_name The user name to be validated. - * @return true User name is valid - * @return false User name is not valid - */ - bool is_user_name_valid(const char *user_name) const - { - std::string str_user_name(user_name); - return str_user_name.length() <= max_user_name_length; - } - - /** - * @brief Check if a user id is valid - * @param user_id User ID to check - * @return true User ID is valid - * @return false User ID is not valid - */ - bool is_user_id_valid(user_credential_user_unique_id_t user_id) - { - return user_id <= max_user_count; - } - /** - * @brief Check if a user type is supported - * @param user_type User type to check - * @return true User type is supported - * @return false User type is not supported - */ - bool is_user_type_supported(user_credential_type_t user_type) const - { - return (supported_user_types_bitmask & (1 << user_type)); - } - - /** - * @brief Check if a credential rule is supported - * @param credential_rule Credential rule to check - * @return true Credential rule is supported - * @return false Credential rule is not supported - */ - bool - is_credential_rule_supported(user_credential_rule_t credential_rule) const - { - return (supported_credential_rules_bitmask & (1 << credential_rule)); - } -}; - -// Associated with a Credential type -struct credential_capabilities { - user_credential_type_t credential_type = 0; - uint16_t max_slot_count = 0; - uint8_t learn_support = 0; - uint8_t min_credential_length = 0; - uint8_t max_credential_length = 0; - uint8_t learn_recommended_timeout = 0; - uint8_t learn_number_of_steps = 0; - - bool is_data_valid = false; - - bool is_learn_supported() const - { - return is_data_valid && learn_support > 0; - } - - bool is_credential_valid(user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const std::vector &credential_data) - { - if (!is_data_valid) { - sl_log_error( - LOG_TAG, - "Credential capabilities are not valid. Try restarting the device."); - return false; - } - - if (credential_type != this->credential_type) { - sl_log_error(LOG_TAG, "Credential type mismatch."); - return false; - } - - if (!is_slot_valid(credential_slot)) { - sl_log_error( - LOG_TAG, - "Slot ID is not valid. Given : %d, Max Supported Slot count : %d", - credential_slot, - max_slot_count); - return false; - } - - if (!is_credential_data_valid(credential_data)) { - sl_log_error(LOG_TAG, - "Credential data size is not valid. Should be between %d " - "and %d, given : %d", - min_credential_length, - max_credential_length, - credential_data.size()); - return false; - } - - return true; - } - - bool is_slot_valid(user_credential_slot_t credential_slot) const - { - return credential_slot <= max_slot_count; - } - - bool - is_credential_data_valid(const std::vector &credential_data) const - { - return (credential_data.size() >= min_credential_length - && credential_data.size() <= max_credential_length); - } -}; - -///////////////////////////////////////////////////////////////////////////// -// Capabilites Helpers -///////////////////////////////////////////////////////////////////////////// -/** - * @brief Get the attributes of a node - * - * @param parent_node Parent node of the attributes - * @param attributes Fill the attribute_store_type_t with the corresponding value inside the pointer - * - * @return sl_status_t SL_STATUS_OK if everything was fine ; otherwise an error code -*/ -sl_status_t get_attributes(attribute_store_node_t parent_node, - std::map attributes) -{ - sl_status_t status = SL_STATUS_OK; - for (auto &attribute: attributes) { - size_t attribute_size = 0; - switch (attribute_store_get_storage_type(attribute.first)) { - case U8_STORAGE_TYPE: - attribute_size = sizeof(uint8_t); - break; - case U16_STORAGE_TYPE: - attribute_size = sizeof(uint16_t); - break; - case U32_STORAGE_TYPE: - attribute_size = sizeof(uint32_t); - break; - default: - sl_log_error( - LOG_TAG, - "Unsupported storage type for attribute %d. Can't get capabilities.", - attribute.first); - return SL_STATUS_FAIL; - } - - sl_status_t current_status - = attribute_store_get_child_reported(parent_node, - attribute.first, - attribute.second, - attribute_size); - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get value for attribute %s", - attribute_store_get_type_name(attribute.first)); - } - - status |= current_status; - } - return status; -} - -/** - * @brief Get the user capabilities of a node - * - * @param endpoint_node Endpoint node - * - * @return user_capabilities User capabilities. is_data_valid will be false if an error occurred -*/ -user_capabilities get_user_capabilities(attribute_store_node_t endpoint_node) -{ - user_capabilities capabilities; - - std::map attributes = { - {ATTRIBUTE(NUMBER_OF_USERS), &capabilities.max_user_count}, - {ATTRIBUTE(SUPPORTED_CREDENTIAL_RULES), - &capabilities.supported_credential_rules_bitmask}, - {ATTRIBUTE(SUPPORTED_USER_TYPES), - &capabilities.supported_user_types_bitmask}, - {ATTRIBUTE(MAX_USERNAME_LENGTH), &capabilities.max_user_name_length}, - {ATTRIBUTE(SUPPORT_USER_SCHEDULE), &capabilities.support_user_schedule}, - {ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM), - &capabilities.support_all_user_checksum}, - {ATTRIBUTE(SUPPORT_USER_CHECKSUM), &capabilities.support_by_user_checksum}}; - - sl_status_t status = get_attributes(endpoint_node, attributes); - - capabilities.is_data_valid = (status == SL_STATUS_OK); - - return capabilities; -} - -/** - * @brief Get the credential capabilities of a node for given credential type - * - * @param endpoint_node Endpoint node - * @param credential_type Credential type - * - * @return credential_capabilities Credential capabilities. is_data_valid will be false if an error occurred -*/ -credential_capabilities - get_credential_capabilities(attribute_store_node_t endpoint_node, - user_credential_type_t credential_type) -{ - credential_capabilities capabilities; - - attribute_store_node_t supported_credential_type_node - = attribute_store_get_node_child_by_value( - endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - REPORTED_ATTRIBUTE, - (uint8_t *)&credential_type, - sizeof(credential_type), - 0); - - if (!attribute_store_node_exists(supported_credential_type_node)) { - sl_log_error(LOG_TAG, - "Credential type %d not supported. Can't get capabilities", - credential_type); - return capabilities; - } - - std::map attributes = { - {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), &capabilities.max_slot_count}, - {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), &capabilities.learn_support}, - {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), &capabilities.min_credential_length}, - {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), &capabilities.max_credential_length}, - {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), - &capabilities.learn_recommended_timeout}, - {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), - &capabilities.learn_number_of_steps}}; - - sl_status_t status - = get_attributes(supported_credential_type_node, attributes); - capabilities.credential_type = credential_type; - capabilities.is_data_valid = (status == SL_STATUS_OK); - - return capabilities; -} - ///////////////////////////////////////////////////////////////////////////// // Type Helpers ///////////////////////////////////////////////////////////////////////////// @@ -420,18 +106,6 @@ uint16_t get_uint16_value(const uint8_t *frame, uint16_t start_index) return extracted_value; } -/////////////////////////////////////////////////////////////////////// -// Mics helpers -/////////////////////////////////////////////////////////////////////// -std::u16string utf8_to_utf16(const std::string &utf8) -{ - std::wstring_convert, char16_t> cnv; - std::u16string s = cnv.from_bytes(utf8); - if (cnv.converted() < utf8.size()) - throw std::runtime_error("incomplete conversion"); - return s; -} - ///////////////////////////////////////////////////////////////////////////// // Command Class Helper ///////////////////////////////////////////////////////////////////////////// @@ -3236,7 +2910,7 @@ sl_status_t zwave_command_class_user_credential_add_new_user( sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); // Check capabilites - user_capabilities capabilites = get_user_capabilities(endpoint_node); + auto capabilites = user_credential::user_capabilities(endpoint_node); if (!capabilites.is_user_valid(user_id, user_type, credential_rule, @@ -3362,7 +3036,7 @@ sl_status_t zwave_command_class_user_credential_modify_user( sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); // Check capabilites - user_capabilities capabilites = get_user_capabilities(endpoint_node); + auto capabilites = user_credential::user_capabilities(endpoint_node); if (!capabilites.is_user_valid(user_id, user_type, credential_rule, @@ -3401,73 +3075,6 @@ sl_status_t zwave_command_class_user_credential_modify_user( return status; } -/** - * @brief Convert credential data str to a vector of uint8_t - * - * @note CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order - * - * @param credential_data Credential data to convert - * @param credential_type Credential type - * @param credential_data_vector Vector to store the converted data - * - * @throws std::runtime_error if the credential data is invalid - * - * @return The converted data -*/ -std::vector - convert_credential_data(const char *credential_data, - user_credential_type_t credential_type) -{ - std::vector credential_data_vector; - std::string credential_data_str(credential_data); - switch (credential_type) { - case CREDENTIAL_REPORT_PASSWORD: { - // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order - auto credential_data_utf16 = utf8_to_utf16(credential_data_str); - for (const auto &c: credential_data_utf16) { - credential_data_vector.push_back((uint8_t)(c >> 8)); - credential_data_vector.push_back((uint8_t)c); - } - } break; - case CREDENTIAL_REPORT_PIN_CODE: - for (const auto &c: credential_data_str) { - if (c < '0' || c > '9') { - throw std::runtime_error( - (boost::format( - "Invalid character in PIN code : %1%. Only digits are allowed.") - % c) - .str()); - } - credential_data_vector.push_back(c); - } - break; - default: - for (const auto &c: credential_data_str) { - credential_data_vector.push_back(c); - } - } - - return credential_data_vector; -} - -std::vector - validate_credential_data(credential_capabilities &capabilities, - const char *credential_data, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) -{ - std::vector credential_data_vector - = convert_credential_data(credential_data, credential_type); - - // Credential not valid, we are not adding it - if (!capabilities.is_credential_valid(credential_type, - credential_slot, - credential_data_vector)) { - throw std::runtime_error("Credential capabilities are not valid."); - } - - return credential_data_vector; -} sl_status_t zwave_command_class_user_credential_add_new_credential( attribute_store_node_t endpoint_node, @@ -3494,7 +3101,7 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( } auto capabilities - = get_credential_capabilities(endpoint_node, credential_type); + = user_credential::credential_capabilities(endpoint_node, credential_type); if (!capabilities.is_slot_valid(credential_slot)) { sl_log_error(LOG_TAG, @@ -3525,10 +3132,8 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( // Process credential data std::vector credential_data_vector - = validate_credential_data(capabilities, - credential_data, - credential_type, - credential_slot); + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); auto credential_slot_node = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), @@ -3583,12 +3188,11 @@ sl_status_t zwave_command_class_user_credential_modify_credential( auto credential_slot_node = nodes.slot_node; // Process credential data auto capabilities - = get_credential_capabilities(endpoint_node, credential_type); + = user_credential::credential_capabilities(endpoint_node, + credential_type); std::vector credential_data_vector - = validate_credential_data(capabilities, - credential_data, - credential_type, - credential_slot); + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); // Modify current data credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) .set_desired(credential_data_vector); @@ -3751,7 +3355,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( credential_learn_timeout); auto credential_capabilities - = get_credential_capabilities(endpoint_node, credential_type); + = user_credential::credential_capabilities(endpoint_node, credential_type); if (!credential_capabilities.is_learn_supported()) { sl_log_error(LOG_TAG, @@ -3803,7 +3407,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( if (credential_learn_timeout == 0) { credential_learn_timeout - = credential_capabilities.learn_recommended_timeout; + = credential_capabilities.get_learn_recommended_timeout(); sl_log_debug(LOG_TAG, "Credential learn timeout is 0. Setting it to default " "reported value (%d seconds).", @@ -3844,7 +3448,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( credential_learn_timeout); auto credential_capabilities - = get_credential_capabilities(endpoint_node, credential_type); + = user_credential::credential_capabilities(endpoint_node, credential_type); if (!credential_capabilities.is_learn_supported()) { sl_log_error(LOG_TAG, @@ -3864,7 +3468,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( if (credential_learn_timeout == 0) { credential_learn_timeout - = credential_capabilities.learn_recommended_timeout; + = credential_capabilities.get_learn_recommended_timeout(); sl_log_debug(LOG_TAG, "Credential learn timeout is 0. Setting it to default " "reported value (%d seconds).", From b138e7955d0562925a815aa8537952d08565d8a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 2 Sep 2024 13:50:54 +0200 Subject: [PATCH 36/60] UIC-3222: Refactor Checksum commands Add a new helper class for clarity --- .../user_credential_checksum_calculator.cpp | 107 +++ .../user_credential_checksum_calculator.h | 58 ++ .../zwave_command_class_user_credential.cpp | 621 ++++++------------ 3 files changed, 356 insertions(+), 430 deletions(-) create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.h diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp new file mode 100644 index 000000000..2b6c5c7f2 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp @@ -0,0 +1,107 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#include "user_credential_checksum_calculator.h" + +#include "zwave_controller_crc16.h" + +// Log +#include "sl_log.h" + +namespace user_credential +{ + +// Used to compute checksums +constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; +constexpr uint8_t MAX_CHAR_SIZE = 64; + +constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; + +std::vector + get_raw_data_from_node(const attribute_store::attribute &node) +{ + std::vector raw_data; + auto value_size + = attribute_store_get_node_value_size(node, REPORTED_ATTRIBUTE); + + if (value_size == 0) { + throw std::runtime_error( + "Failed to get value size from attribute store for attribute " + + node.name_and_id()); + } + + raw_data.resize(value_size); + sl_status_t status + = attribute_store_get_node_attribute_value(node, + REPORTED_ATTRIBUTE, + raw_data.data(), + &value_size); + + if (status != SL_STATUS_OK) { + throw std::runtime_error("Failed to get value for attribute " + + node.name_and_id()); + } + + return raw_data; +} + +void checksum_calculator::add_node(const attribute_store::attribute &node) +{ + if (!node.is_valid()) { + sl_log_error(LOG_TAG, "Can't find node %d. Not adding to checksum.", node); + throw std::runtime_error("Invalid node"); + } + + // Will throw and exception if the conversion failed + auto raw_data = get_raw_data_from_node(node); + + // Add the raw data to the checksum data + auto storage_type = attribute_store_get_storage_type(node.type()); + + // Remove the NULL terminator if we are dealing with a string + if (storage_type == C_STRING_STORAGE_TYPE) { + raw_data.pop_back(); + } + + // Send it as is but append the size of the value at the beginning + if (storage_type == C_STRING_STORAGE_TYPE + || storage_type == BYTE_ARRAY_STORAGE_TYPE + || storage_type == FIXED_SIZE_STRUCT_STORAGE_TYPE + || storage_type == INVALID_STORAGE_TYPE) { + raw_data.insert(raw_data.begin(), raw_data.size()); + checksum_data.insert(checksum_data.end(), raw_data.begin(), raw_data.end()); + } + // Otherwise the MSB is always the first in Z-Wave frames + // (and in attribute store it is last) so we need to reverse the order + else { + checksum_data.insert(checksum_data.end(), + raw_data.rbegin(), + raw_data.rend()); + } +} + +user_credential_checksum_t checksum_calculator::compute_checksum() +{ + user_credential_checksum_t computed_checksum = 0; + // If checksum data is empty, the checksum is 0. The guard is present to avoid + // zwave_controller_crc16 to return CRC_INITIALIZATION_VALUE if checksum_data is empty. + // See CC:0083.01.19.11.016 & CC:0083.01.17.11.013 + if (checksum_data.size() > 0) { + computed_checksum = zwave_controller_crc16(CRC_INITIALIZATION_VALUE, + checksum_data.data(), + checksum_data.size()); + } + return computed_checksum; +} + +} // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.h new file mode 100644 index 000000000..9e54c2c4f --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.h @@ -0,0 +1,58 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ +#ifndef USER_CREDENTIAL_CHECKSUM_CALCULATOR_H +#define USER_CREDENTIAL_CHECKSUM_CALCULATOR_H + +// Cpp includes +#include + +// Unify +#include "attribute.hpp" + +// Types +#include "zwave_command_class_user_credential_types.h" + +namespace user_credential +{ + +/** + * @brief Compute the checksum based on the attribute store + * + */ +class checksum_calculator +{ + public: + /** + * @brief Compute a node value and add it to the current checksum + * + * @param node Node to compute the checksum from + * + * @throws std::runtime_error If the node is invalid or if the conversion failed + */ + void add_node(const attribute_store::attribute &attribute); + /** + * @brief Compute the checksum of the added nodes + * + * @note If no nodes are added, the checksum is 0 (see CC:0083.01.19.11.016 & CC:0083.01.17.11.013) + * + * @return user_credential_checksum_t + */ + user_credential_checksum_t compute_checksum(); + + private: + std::vector checksum_data; +}; + +} // namespace user_credential + +#endif // USER_CREDENTIAL_CHECKSUM_CALCULATOR_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 700983d48..4e1ef4fba 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -51,18 +51,13 @@ // Private helpers #include "private/user_credential/user_credential_user_capabilities.h" #include "private/user_credential/user_credential_credential_capabilities.h" +#include "private/user_credential/user_credential_checksum_calculator.h" // Macro #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type // Constexpr constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; -// Used to get user names -// If the user name has a size > to this number, we will truncate it -// Specification says that payload data should not exceeded 64 bytes. -constexpr uint8_t MAX_CHAR_SIZE = 64; -// Used to compute checksums -constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; // Using using attribute_callback = std::function; @@ -733,136 +728,6 @@ credential_id_nodes get_credential_identifier_nodes( // Attributes helpers ///////////////////////////////////////////////////////////////////////////// -/** - * @brief Get value inside the node and store it in a uint8_t vector - * - * @param node Node to get the value from - * @param data Vector to store the value (output). It will be cleared before any data is stored in it - * @param value_state Value state (reported, desired,...). Default to Reported - * - * @return sl_status_t SL_STATUS_OK if everything was fine - * @return SL_STATUS_NOT_SUPPORTED If the storage type is not supported or other errors -*/ -sl_status_t node_to_uint8_vector(attribute_store_node_t node, - std::vector &data, - attribute_store_node_value_state_t value_state - = REPORTED_ATTRIBUTE) -{ - data.clear(); - - auto node_type = attribute_store_get_node_type(node); - auto node_storage_type = attribute_store_get_storage_type(node_type); - auto attribute_description = attribute_store_get_type_name(node_type); - - sl_status_t status; - switch (node_storage_type) { - case U8_STORAGE_TYPE: { - uint8_t uint8_value; - status = attribute_store_read_value(node, - value_state, - &uint8_value, - sizeof(uint8_value)); - data.push_back(uint8_value); - } break; - case U16_STORAGE_TYPE: { - uint16_t uint16_value; - status = attribute_store_read_value(node, - value_state, - &uint16_value, - sizeof(uint16_value)); - data.push_back((uint16_value & 0xFF00) >> 8); - data.push_back((uint16_value & 0x00FF)); - } break; - // Variable length field - case BYTE_ARRAY_STORAGE_TYPE: { - // First get the length - auto credential_data_length - = attribute_store_get_node_value_size(node, value_state); - - // + 1 for the length - data.resize(credential_data_length + 1); - data[0] = credential_data_length; - status - = attribute_store_read_value(node, - value_state, - data.data() + 1, // Offset for the length - credential_data_length); - } break; - - case C_STRING_STORAGE_TYPE: { - char c_user_name[MAX_CHAR_SIZE]; - // Unfortunately attribute_store_get_string is not exposed so we need to do this - switch (value_state) { - case DESIRED_OR_REPORTED_ATTRIBUTE: - status - = attribute_store_get_desired_else_reported_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - case DESIRED_ATTRIBUTE: - status = attribute_store_get_desired_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - case REPORTED_ATTRIBUTE: - status = attribute_store_get_reported_string(node, - c_user_name, - MAX_CHAR_SIZE); - break; - } - - std::string user_name = c_user_name; - data.push_back(user_name.length()); - for (const char &c: user_name) { - data.push_back(c); - } - } break; - default: - sl_log_critical(LOG_TAG, - "Not supported type for %s", - attribute_description); - return SL_STATUS_FAIL; - } - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Can't get value of Attribute %s", - attribute_description); - return SL_STATUS_NOT_SUPPORTED; - } - - return SL_STATUS_OK; -} - -/** - * @brief Compute a node value and add it to the current checksum - * - * @param current_checksum Current checksum (can be empty) - * @param node Node to compute the checksum from - * - * @return true If the node was added to the checksum - * @return false If the node was not added to the checksum -*/ -bool add_node_to_checksum(std::vector ¤t_checksum, - attribute_store_node_t node) -{ - if (!attribute_store_node_exists(node)) { - sl_log_error(LOG_TAG, "Can't find node %d. Not adding to checksum.", node); - return false; - } - std::vector data; - if (node_to_uint8_vector(node, data) != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't convert node %d to uint8_t vector. Not adding to checksum.", - node); - return false; - } - current_checksum.insert(current_checksum.end(), data.begin(), data.end()); - - return true; -}; - /** * @brief Updates the desired values of attributes in the attribute store. * @@ -948,11 +813,6 @@ static void zwave_command_class_user_credential_on_version_attribute_update( attribute_store_add_if_missing(endpoint_node, attributes, COUNT_OF(attributes)); - - // Listen to - // zwave_command_class_notification_register_event_callback( - // endpoint_node, - // &on_notification_event); } ///////////////////////////////////////////////////////////////////////////// @@ -1164,13 +1024,9 @@ static sl_status_t zwave_command_class_user_credential_all_user_checksum_get( { sl_log_debug(LOG_TAG, "All User Checksum Get"); - ZW_ALL_USERS_CHECKSUM_GET_FRAME *get_frame - = (ZW_ALL_USERS_CHECKSUM_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = ALL_USERS_CHECKSUM_GET; - *frame_length = sizeof(ZW_ALL_USERS_CHECKSUM_GET_FRAME); - - return SL_STATUS_OK; + return frame_generator.generate_no_args_frame(ALL_USERS_CHECKSUM_GET, + frame, + frame_length); } sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( @@ -1178,22 +1034,30 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( const uint8_t *frame_data, uint16_t frame_length) { - if (frame_length != 4) { - return SL_STATUS_NOT_SUPPORTED; - } + constexpr uint8_t expected_size = sizeof(ZW_ALL_USERS_CHECKSUM_REPORT_FRAME); - sl_log_debug(LOG_TAG, "All User Checksum Report"); - - attribute_store_node_t endpoint_node + attribute_store::attribute endpoint_node = zwave_command_class_get_endpoint_node(connection_info); - user_credential_all_users_checksum_t all_users_checksum - = get_uint16_value(frame_data, 2); + try { + zwave_frame_parser parser(frame_data, frame_length); - attribute_store_set_child_reported(endpoint_node, - ATTRIBUTE(ALL_USERS_CHECKSUM), - &all_users_checksum, - sizeof(all_users_checksum)); + if (!parser.is_frame_size_valid(expected_size)) { + sl_log_error(LOG_TAG, + "Invalid frame size for All User Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } + + parser.read_sequential( + 2, + endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM))); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing All User Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } return SL_STATUS_OK; } @@ -2426,38 +2290,29 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( * @param checksum_data The data to compute the checksum. Checksum will be 0 if empty. * @param expected_checksum The expected checksum * - * @return The computed checksum of checksum_data + * @return SL_STATUS_OK if checksum is correct, SL_STATUS_FAIL otherwise */ -user_credential_checksum_t compute_checksum_and_verify_integrity( - attribute_store_node_t base_node, - attribute_store_type_t checksum_error_type, - std::vector checksum_data, - user_credential_checksum_t expected_checksum) -{ - user_credential_checksum_t computed_checksum = 0; - // If checksum data is empty, the checksum is 0. The guard is present to avoid - // zwave_controller_crc16 to return CRC_INITIALIZATION_VALUE if checksum_data is empty. - // See CC:0083.01.19.11.016 & CC:0083.01.17.11.013 - if (checksum_data.size() > 0) { - computed_checksum = zwave_controller_crc16(CRC_INITIALIZATION_VALUE, - checksum_data.data(), - checksum_data.size()); - } +sl_status_t check_checksum_value(attribute_store::attribute base_node, + attribute_store_type_t checksum_error_type, + user_credential_checksum_t computed_checksum, + user_credential_checksum_t expected_checksum) +{ + sl_status_t status = SL_STATUS_FAIL; if (computed_checksum != expected_checksum) { - // Set checksum mismatch error - attribute_store_set_child_reported(base_node, - checksum_error_type, - &computed_checksum, - sizeof(computed_checksum)); + sl_log_error(LOG_TAG, + "Checksum mismatch (%s). Expected 0x%X, got 0x%X", + base_node.value_to_string().c_str(), + expected_checksum, + computed_checksum); + base_node.emplace_node(checksum_error_type).set_reported(computed_checksum); } else { // If we don't have any errors we remove the checksum_error_type node - auto checksum_mismatch_node - = attribute_store_get_first_child_by_type(base_node, checksum_error_type); - attribute_store_delete_node(checksum_mismatch_node); + base_node.child_by_type(checksum_error_type).delete_node(); + status = SL_STATUS_OK; } - return computed_checksum; + return status; } ///////////////////////////////////////////////////////////////////////////// @@ -2502,140 +2357,90 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t EXPECTED_FRAME_LENGTH = 6; - if (frame_length != EXPECTED_FRAME_LENGTH) { - sl_log_error(LOG_TAG, - "USER_CHECKSUM_REPORT frame length is not " - "valid. Expected %d, got %d", - EXPECTED_FRAME_LENGTH, - frame_length); - return SL_STATUS_NOT_SUPPORTED; - } + sl_status_t result = SL_STATUS_FAIL; - constexpr uint8_t INDEX_SOURCE_USER_ID = 2; - constexpr uint8_t INDEX_USER_CHECKSUM = 4; + constexpr uint8_t expected_frame_length + = sizeof(ZW_USER_CHECKSUM_REPORT_FRAME); - attribute_store_node_t endpoint_node + attribute_store::attribute endpoint_node = zwave_command_class_get_endpoint_node(connection_info); - // Interpret frame - const user_credential_user_unique_id_t user_id - = get_uint16_value(frame_data, INDEX_SOURCE_USER_ID); - const user_credential_checksum_t user_checksum - = get_uint16_value(frame_data, INDEX_USER_CHECKSUM); - - sl_log_debug(LOG_TAG, - "User Checksum Report. Source User ID: %d / " - "Checksum: 0x%X", - user_id, - user_checksum); - - attribute_store_node_t user_id_node; - if (!get_user_id_node(endpoint_node, - user_id, - REPORTED_ATTRIBUTE, - user_id_node)) { - sl_log_error(LOG_TAG, - "Can't find User %d reported by User Checksum Report", - user_id); - return SL_STATUS_NOT_SUPPORTED; - } + try { + zwave_frame_parser parser(frame_data, frame_length); - // Set reported value - attribute_store_set_child_reported(user_id_node, - ATTRIBUTE(USER_CHECKSUM), - &user_checksum, - sizeof(user_checksum)); + if (!parser.is_frame_size_valid(expected_frame_length)) { + sl_log_error(LOG_TAG, + "Invalid frame size for User Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } - // Compute checksum ourselves to see if it matches - std::vector checksum_data; + // Parse the frame + const auto user_id + = parser.read_sequential(2); + const auto user_checksum + = parser.read_sequential(2); - // First gather all the User values - const std::vector user_attributes = { - ATTRIBUTE(USER_TYPE), - ATTRIBUTE(USER_ACTIVE_STATE), - ATTRIBUTE(CREDENTIAL_RULE), - ATTRIBUTE(USER_NAME_ENCODING), - ATTRIBUTE(USER_NAME), - }; - attribute_store::attribute cpp_user_id_node(user_id_node); - for (auto attribute: user_attributes) { - if (!add_node_to_checksum(checksum_data, - cpp_user_id_node.child_by_type(attribute))) { - return SL_STATUS_FAIL; - } - } + sl_log_debug(LOG_TAG, + "User Checksum Report. Source User ID: %d / " + "Checksum: 0x%X", + user_id, + user_checksum); - // The all credential data - auto credential_type_node_count - = attribute_store_get_node_child_count_by_type(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE)); + auto user_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - for (size_t credential_index = 0; - credential_index < credential_type_node_count; - credential_index++) { - attribute_store_node_t credential_type_node - = attribute_store_get_node_child_by_type(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - credential_index); - auto credential_slot_node_count - = attribute_store_get_node_child_count_by_type( - credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - - for (size_t slot_index = 0; slot_index < credential_slot_node_count; - slot_index++) { - attribute_store_node_t credential_slot_node - = attribute_store_get_node_child_by_type(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - slot_index); - // We don't have all the data for this slot, skipping it. - if (!attribute_store_is_reported_defined(credential_slot_node)) { - sl_log_debug( - LOG_TAG, - "Credential Slot #%d is not defined. Not adding to checksum.", - slot_index); - continue; - } + user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) + .set_reported(user_checksum); - // Add credential type to checksum - if (!add_node_to_checksum(checksum_data, credential_type_node)) { - return SL_STATUS_FAIL; - } + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; - // Add credential slot to checksum - if (!add_node_to_checksum(checksum_data, credential_slot_node)) { - return SL_STATUS_FAIL; - } + // First gather all the User values + const std::vector user_attributes = { + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME), + }; + for (auto attribute: user_attributes) { + checksum_calculator.add_node(user_node.child_by_type(attribute)); + } - auto credential_data_node - = attribute_store_get_first_child_by_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA)); + // The all credential data + for (auto credential_type_node: + user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%d reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } - // Add credential data to checksum - if (!add_node_to_checksum(checksum_data, credential_data_node)) { - return SL_STATUS_FAIL; + // Add credential type to checksum + checksum_calculator.add_node(credential_type_node); + // Add credential slot to checksum + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); } } - } - - user_credential_checksum_t computed_checksum - = compute_checksum_and_verify_integrity( - user_id_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), - checksum_data, - user_checksum); - if (computed_checksum != user_checksum) { + result = check_checksum_value(user_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + user_checksum); + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Checksum mismatch for user %d. Expected 0x%X, got 0x%X", - user_id, - user_checksum, - computed_checksum); - return SL_STATUS_FAIL; + "Error while parsing User Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - return SL_STATUS_OK; + return result; } ///////////////////////////////////////////////////////////////////////////// @@ -2647,37 +2452,31 @@ static sl_status_t zwave_command_class_user_credential_credential_checksum_get( { sl_log_debug(LOG_TAG, "Credential Checksum Get"); - auto credential_type_node = attribute_store_get_first_parent_with_type( - node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); + attribute_store::attribute credential_checksum_node(node); + try { + auto credential_type_node = credential_checksum_node.first_parent( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_error( - LOG_TAG, - "Can't find Credential Type node. Not sending Credential Checksum Get."); - return SL_STATUS_NOT_SUPPORTED; - } + if (!credential_type_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find Credential Type node. Not sending Credential " + "Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } - user_credential_type_t credential_type = 0; - sl_status_t status = attribute_store_get_reported(credential_type_node, - &credential_type, - sizeof(credential_type)); + frame_generator.initialize_frame(CREDENTIAL_CHECKSUM_GET, + frame, + sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME)); - if (status != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Can't get credential type value. Not sending Credential Checksum Get."); + frame_generator.add_value(credential_type_node, REPORTED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating Credential Checksum Get frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - ZW_CREDENTIAL_CHECKSUM_GET_FRAME *get_frame - = (ZW_CREDENTIAL_CHECKSUM_GET_FRAME *)frame; - get_frame->cmdClass = COMMAND_CLASS_USER_CREDENTIAL; - get_frame->cmd = CREDENTIAL_CHECKSUM_GET; - get_frame->credentialType = credential_type; - - *frame_length = sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME); - return SL_STATUS_OK; } @@ -2687,118 +2486,82 @@ sl_status_t const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t EXPECTED_FRAME_LENGTH = 5; - if (frame_length != EXPECTED_FRAME_LENGTH) { - sl_log_error(LOG_TAG, - "CREDENTIAL_CHECKSUM_REPORT frame length is not " - "valid. Expected %d, got %d", - EXPECTED_FRAME_LENGTH, - frame_length); - return SL_STATUS_NOT_SUPPORTED; - } + sl_status_t result = SL_STATUS_FAIL; - constexpr uint8_t INDEX_CREDENTIAL_TYPE = 2; - constexpr uint8_t INDEX_USER_CHECKSUM = 3; - - attribute_store_node_t endpoint_node + attribute_store::attribute endpoint_node = zwave_command_class_get_endpoint_node(connection_info); - // Interpret frame - const user_credential_type_t credential_type - = frame_data[INDEX_CREDENTIAL_TYPE]; - const user_credential_checksum_t credential_checksum - = get_uint16_value(frame_data, INDEX_USER_CHECKSUM); - - sl_log_debug(LOG_TAG, - "Credential Checksum Report. Credential type: %d / " - "Checksum: 0x%X", - credential_type, - credential_checksum); - - attribute_store_node_t credential_type_node - = attribute_store_get_node_child_by_value( - endpoint_node, - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - REPORTED_ATTRIBUTE, - (uint8_t *)&credential_type, - sizeof(credential_type), - 0); - - if (!attribute_store_node_exists(credential_type_node)) { - sl_log_error( - LOG_TAG, - "Can't find Credential Type %d reported by Credential Checksum " - "Report", - credential_type); - return SL_STATUS_NOT_SUPPORTED; - } + constexpr uint8_t expected_frame_length + = sizeof(ZW_CREDENTIAL_CHECKSUM_REPORT_FRAME); + try { + zwave_frame_parser parser(frame_data, frame_length); - // Set reported value - attribute_store_set_child_reported(credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM), - &credential_checksum, - sizeof(credential_checksum)); + if (!parser.is_frame_size_valid(expected_frame_length)) { + sl_log_error(LOG_TAG, + "Invalid frame size for Credential Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } - // Compute checksum ourselves to see if it matches - std::vector checksum_data; + // Parse the frame + const user_credential_type_t credential_type = parser.read_byte(); + const auto credential_checksum + = parser.read_sequential(2); - auto credential_type_nodes - = get_all_credential_type_nodes(endpoint_node, credential_type); - for (auto credential_type_node: credential_type_nodes) { - auto credential_slot_node_count - = attribute_store_get_node_child_count_by_type( - credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT)); - - for (size_t slot_index = 0; slot_index < credential_slot_node_count; - slot_index++) { - attribute_store_node_t credential_slot_node - = attribute_store_get_node_child_by_type(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - slot_index); - // We don't have all the data for this slot, skipping it. - if (!attribute_store_is_reported_defined(credential_slot_node)) { - sl_log_debug( - LOG_TAG, - "Credential Slot #%d is not defined. Not adding to checksum.", - slot_index); - continue; - } + sl_log_debug(LOG_TAG, + "Credential Checksum Report. Credential type: %d / " + "Checksum: 0x%X", + credential_type, + credential_checksum); - // Add credential slot to checksum - if (!add_node_to_checksum(checksum_data, credential_slot_node)) { - return SL_STATUS_FAIL; - } + // Get the credential type node + auto credential_type_node = endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + if (!credential_type_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Can't find Credential Type %d reported by Credential Checksum Report", + credential_type); + return SL_STATUS_FAIL; + } - auto credential_data_node - = attribute_store_get_first_child_by_type(credential_slot_node, - ATTRIBUTE(CREDENTIAL_DATA)); + credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)) + .set_reported(credential_checksum); - // Add credential data to checksum - if (!add_node_to_checksum(checksum_data, credential_data_node)) { - return SL_STATUS_FAIL; - } - } - } + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; + for_each_credential_type_nodes( + endpoint_node, + [&](auto credential_type_node) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%s reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } - user_credential_checksum_t computed_checksum - = compute_checksum_and_verify_integrity( - credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), - checksum_data, - credential_checksum); + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); + } + }, + credential_type); - if (computed_checksum != credential_checksum) { - sl_log_error( - LOG_TAG, - "Checksum mismatch for credential type %d. Expected 0x%X, got 0x%X", - credential_type, - credential_checksum, - computed_checksum); - return SL_STATUS_FAIL; + result = check_checksum_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + credential_checksum); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - return SL_STATUS_OK; + return result; } ///////////////////////////////////////////////////////////////////////////// @@ -3075,7 +2838,6 @@ sl_status_t zwave_command_class_user_credential_modify_user( return status; } - sl_status_t zwave_command_class_user_credential_add_new_credential( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id, @@ -3518,7 +3280,6 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( user_credential_user_unique_id_t destination_user_id, user_credential_slot_t destination_credential_slot) { - try { auto nodes = get_credential_identifier_nodes( endpoint_node, @@ -3533,7 +3294,7 @@ sl_status_t zwave_command_class_user_credential_uuic_association_set( nodes.slot_node .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) .set_desired(destination_credential_slot); - } catch (std::exception& e) { + } catch (std::exception &e) { sl_log_error(LOG_TAG, "Error while setting up uuic asociation set : %s", e.what()); @@ -3555,7 +3316,7 @@ sl_status_t zwave_command_class_user_credential_get_user_checksum( // If node already exists, we clear its value to trigger the GET checksum_node.clear_reported(); checksum_node.clear_desired(); - } catch(const std::exception& e) { + } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while setting up user get checksum : %s", e.what()); @@ -3583,8 +3344,8 @@ sl_status_t zwave_command_class_user_credential_get_credential_checksum( return SL_STATUS_FAIL; } - auto checksum_node - = supported_credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); + auto checksum_node = supported_credential_type_node.emplace_node( + ATTRIBUTE(CREDENTIAL_CHECKSUM)); // If node already exists, we clear its value to trigger the GET checksum_node.clear_reported(); checksum_node.clear_desired(); From 435d065db9bba93ea18dc9febb79570a45d40b7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 3 Sep 2024 11:51:49 +0200 Subject: [PATCH 37/60] UIC-3222: Refactor UUIC association Much simpler and more efficient thanks to change parent feature --- .../zwave_command_class_user_credential.cpp | 3023 ++++++++--------- ...ave_command_class_user_credential_test.cpp | 27 +- 2 files changed, 1514 insertions(+), 1536 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 4e1ef4fba..bc0d85509 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -1746,540 +1746,480 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( const uint8_t *frame_data, uint16_t frame_length) { - constexpr uint8_t EXPECTED_FRAME_LENGTH = 12; - if (frame_length != EXPECTED_FRAME_LENGTH) { - sl_log_error(LOG_TAG, - "USER_CREDENTIAL_ASSOCIATION_REPORT frame length is not " - "valid. Expected %d, got %d", - EXPECTED_FRAME_LENGTH, - frame_length); - return SL_STATUS_NOT_SUPPORTED; - } + sl_log_debug(LOG_TAG, "UUIC Association Report"); - constexpr uint8_t INDEX_SOURCE_USER_ID = 2; - constexpr uint8_t INDEX_SOURCE_CREDENTIAL_TYPE = 4; - constexpr uint8_t INDEX_SOURCE_CREDENTIAL_SLOT = 5; - constexpr uint8_t INDEX_DESTINATION_USER_ID = 7; - constexpr uint8_t INDEX_DESTINATION_CREDENTIAL_SLOT = 9; - constexpr uint8_t INDEX_ASSOCIATION_STATUS = 11; + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - attribute_store_node_t endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + const uint8_t expected_size + = sizeof(ZW_USER_CREDENTIAL_ASSOCIATION_REPORT_FRAME); - // Interpret frame - const user_credential_user_unique_id_t source_user_id - = get_uint16_value(frame_data, INDEX_SOURCE_USER_ID); - const user_credential_type_t source_credential_type - = frame_data[INDEX_SOURCE_CREDENTIAL_TYPE]; - const user_credential_slot_t source_credential_slot - = get_uint16_value(frame_data, INDEX_SOURCE_CREDENTIAL_SLOT); - const user_credential_user_unique_id_t destination_user_id - = get_uint16_value(frame_data, INDEX_DESTINATION_USER_ID); - const user_credential_slot_t destination_credential_slot - = get_uint16_value(frame_data, INDEX_DESTINATION_CREDENTIAL_SLOT); - const uint8_t association_status = frame_data[INDEX_ASSOCIATION_STATUS]; + try { + zwave_frame_parser parser(frame_data, frame_length); - sl_log_debug(LOG_TAG, - "User Unique Identifier Credential Association Report. Source " - "User ID: %d / " - "Source Credential Type: %d / Source Credential Slot: %d / " - "Destination User ID: %d / Destination Credential Slot: %d", - source_user_id, - source_credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot); - - // Get nodes - attribute_store_node_t source_credential_type_node; - attribute_store_node_t source_credential_slot_node; - get_credential_type_node(endpoint_node, - source_user_id, - source_credential_type, - REPORTED_ATTRIBUTE, - source_credential_type_node); - get_credential_slot_node(source_credential_type_node, - source_credential_slot, - REPORTED_ATTRIBUTE, - source_credential_slot_node); + if (!parser.is_frame_size_valid(expected_size)) { + sl_log_error(LOG_TAG, + "Invalid frame size for UUIC Association Report frame"); + return SL_STATUS_FAIL; + } - if (!attribute_store_node_exists(source_credential_type_node) - || !attribute_store_node_exists(source_credential_slot_node)) { - sl_log_error(LOG_TAG, - "Can't find User %d, Credential Type %d, " - "Credential Slot %d reported by User Unique Identifier " - "Credential Association Report", + // Parse the frame + const auto source_user_id + = parser.read_sequential(2); + const user_credential_type_t source_credential_type = parser.read_byte(); + const auto source_credential_slot + = parser.read_sequential(2); + const auto destination_user_id + = parser.read_sequential(2); + const auto destination_credential_slot + = parser.read_sequential(2); + const uint8_t association_status = parser.read_byte(); + + sl_log_debug(LOG_TAG, + "User Unique Identifier Credential Association Report. Source " + "User ID: %d / " + "Source Credential Type: %d / Source Credential Slot: %d / " + "Destination User ID: %d / Destination Credential Slot: %d", + "Association status : %d", source_user_id, source_credential_type, - source_credential_slot); - return SL_STATUS_NOT_SUPPORTED; - } - - // Set association status - attribute_store_set_child_reported(source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_STATUS), - &association_status, - sizeof(association_status)); - - // Clean up association data so ZPC won't try to send the SET command again - auto association_destination_user_id_node - = attribute_store_get_first_child_by_type( - source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)); - auto association_destination_credential_slot_node - = attribute_store_get_first_child_by_type( - source_credential_slot_node, - ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)); - attribute_store_delete_node(association_destination_user_id_node); - attribute_store_delete_node(association_destination_credential_slot_node); - - if (association_status != USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS) { - sl_log_error(LOG_TAG, - "User Unique Identifier Credential Association error. " - "Reported status code : %d", + source_credential_slot, + destination_user_id, + destination_credential_slot, association_status); - return SL_STATUS_OK; - } - // Simple case : we only have to change the slot number - if (destination_user_id == source_user_id) { - sl_log_info(LOG_TAG, - "Moving slot %d to slot %d (user %d)", - source_credential_slot, - destination_credential_slot, - destination_user_id); - - return attribute_store_set_reported(source_credential_slot_node, - &destination_credential_slot, - sizeof(destination_credential_slot)); - } + // Get nodes + auto source_credential_nodes = get_credential_identifier_nodes( + endpoint_node, + {source_user_id, REPORTED_ATTRIBUTE}, + {source_credential_type, REPORTED_ATTRIBUTE}, + {source_credential_slot, REPORTED_ATTRIBUTE}); - // Complex case : we have to move the slot to another user - sl_log_info(LOG_TAG, - "Moving slot %d (user %d) to slot %d (user %d)", - source_credential_slot, - source_user_id, - destination_credential_slot, - destination_user_id); - - // Get user node - attribute_store_node_t destination_user_id_node; - get_user_id_node(endpoint_node, - destination_user_id, - REPORTED_ATTRIBUTE, - destination_user_id_node); - - if (!attribute_store_node_exists(destination_user_id_node)) { - sl_log_error(LOG_TAG, - "Can't find User %d reported by User Unique Identifier " - "Credential Association Report", - destination_user_id); - return SL_STATUS_NOT_SUPPORTED; - } + // Set association status + auto source_credential_slot_node = source_credential_nodes.slot_node; + source_credential_slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_STATUS)) + .set_reported(association_status); + + // Clean up association data so ZPC won't try to send the SET command again + std::vector attributes_to_be_deleted + = {ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)}; + for (auto attribute_type: attributes_to_be_deleted) { + source_credential_slot_node.child_by_type(attribute_type).delete_node(); + } - // Get destination type node - attribute_store_node_t destination_credential_type_node; - // Look for it if it exists - get_credential_type_node(endpoint_node, - destination_user_id, - source_credential_type, - REPORTED_ATTRIBUTE, - destination_credential_type_node); - // If it doesn't exists yet we create it - if (!attribute_store_node_exists(destination_credential_type_node)) { - destination_credential_type_node - = attribute_store_emplace(destination_user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &source_credential_type, - sizeof(source_credential_type)); - } + // If something went wrong end device side, log the error and return + // This should handle the slot already taken case + if (association_status != USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS) { + sl_log_error(LOG_TAG, + "User Unique Identifier Credential Association error. " + "Reported status code : %d", + association_status); + return SL_STATUS_OK; + } - // Get destination slot node (if we are here we assume that it doesn't exists) - attribute_store_node_t destination_credential_slot_node - = attribute_store_emplace(destination_credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - &destination_credential_slot, - sizeof(destination_credential_slot)); - - // Copy attribute tree - attribute_store::attribute cpp_source_credential_slot_node( - source_credential_slot_node); - attribute_store::attribute cpp_destination_credential_slot_node( - destination_credential_slot_node); - - // Can't use walk_tree here since we need a capturing lambda - // Define the lambda explicitly since it is recursive https://stackoverflow.com/a/4081391 - std::function - deep_copy_reported_attributes; - deep_copy_reported_attributes - = [&](attribute_store::attribute cpp_current_node, - attribute_store::attribute cpp_parent_node) { - // Ignore fields that doesn't have a reported value - if (!cpp_current_node.reported_exists()) { - return; - } - attribute_store_node_t destination_node; - // If we are not at the root node, add new node - if (cpp_current_node.type() != cpp_parent_node.type()) { - destination_node = attribute_store_add_node(cpp_current_node.type(), - cpp_parent_node); - - attribute_store_copy_value(cpp_current_node, - destination_node, - REPORTED_ATTRIBUTE); - } - // Check node children - for (auto child: cpp_current_node.children()) { - // If we are not at the root, need to copy the child attribute - if (cpp_current_node.type() != cpp_parent_node.type()) { - cpp_parent_node = destination_node; - } - deep_copy_reported_attributes(child, cpp_parent_node); - } - }; - deep_copy_reported_attributes(cpp_source_credential_slot_node, - cpp_destination_credential_slot_node); + // Simple case : we only have to change the slot number + if (destination_user_id == source_user_id) { + sl_log_info(LOG_TAG, + "Moving slot %d to slot %d (user %d)", + source_credential_slot, + destination_credential_slot, + destination_user_id); + source_credential_slot_node.set_reported(destination_credential_slot); + } else { + // Complex case : we have to move the slot to another user + sl_log_info(LOG_TAG, + "Moving slot %d (user %d) to slot %d (user %d)", + source_credential_slot, + source_user_id, + destination_credential_slot, + destination_user_id); + + + // Get destination user node + auto destination_user_id_node + = get_user_unique_id_node(endpoint_node, + destination_user_id, + REPORTED_ATTRIBUTE); + + // Get new parent + auto destination_credential_type_node + = destination_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + source_credential_type); + + sl_status_t result = source_credential_slot_node.change_parent( + destination_credential_type_node); + if (result != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Error while moving slot %d (user %d) to slot %d (user %d)", + source_credential_slot, + source_user_id, + destination_credential_slot, + destination_user_id); + return result; + } - // Then remove the old node - attribute_store_delete_node(source_credential_slot_node); + source_credential_slot_node.set_reported(destination_credential_slot); + } + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing UUIC Association Report frame : %s", + e.what()); + return SL_STATUS_FAIL; + } return SL_STATUS_OK; } -///////////////////////////////////////////////////////////////////////////// -// User Set/Get/Report/Set Error Report -///////////////////////////////////////////////////////////////////////////// - -static sl_status_t zwave_command_class_user_credential_user_set( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) -{ - try { - // Node setup - attribute_store::attribute user_operation_type_node(node); - attribute_store::attribute user_unique_id_node - = user_operation_type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - // Get Values - auto user_unique_id - = user_unique_id_node - .desired_or_reported(); - auto user_operation_type - = user_operation_type_node.desired(); - - const bool is_delete_operation - = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); - - uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; - uint8_t user_name_size = 0; + ///////////////////////////////////////////////////////////////////////////// + // User Set/Get/Report/Set Error Report + ///////////////////////////////////////////////////////////////////////////// + + static sl_status_t zwave_command_class_user_credential_user_set( + attribute_store_node_t node, + uint8_t * frame, + uint16_t * frame_length) + { + try { + // Node setup + attribute_store::attribute user_operation_type_node(node); + attribute_store::attribute user_unique_id_node + = user_operation_type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + // Get Values + auto user_unique_id + = user_unique_id_node + .desired_or_reported(); + auto user_operation_type + = user_operation_type_node.desired(); + + const bool is_delete_operation + = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); + + uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; + uint8_t user_name_size = 0; + + if (!is_delete_operation) { + user_name_size = static_cast( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) + .reported() + .size()); + } - if (!is_delete_operation) { - user_name_size = static_cast( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) - .reported() - .size()); - } + // Append the user name size (will be 0 if is delete operation) + expected_frame_size += user_name_size; - // Append the user name size (will be 0 if is delete operation) - expected_frame_size += user_name_size; + sl_log_debug(LOG_TAG, + "User SET for user %d (operation type : %d)", + user_unique_id, + user_operation_type); - sl_log_debug(LOG_TAG, - "User SET for user %d (operation type : %d)", - user_unique_id, - user_operation_type); + // Creating the frame + frame_generator.initialize_frame(USER_SET, frame, expected_frame_size); - // Creating the frame - frame_generator.initialize_frame(USER_SET, frame, expected_frame_size); + frame_generator.add_value(user_operation_type_node, DESIRED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node, + DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value(user_operation_type_node, DESIRED_ATTRIBUTE); - frame_generator.add_value(user_unique_id_node, - DESIRED_OR_REPORTED_ATTRIBUTE); + if (!is_delete_operation) { + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_TYPE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_ACTIVE_STATE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_RULE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node.child_by_type( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME_ENCODING)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_raw_byte(user_name_size); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)), + DESIRED_OR_REPORTED_ATTRIBUTE); + } - if (!is_delete_operation) { - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_TYPE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_ACTIVE_STATE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_RULE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value(user_unique_id_node.child_by_type( - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME_ENCODING)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_raw_byte(user_name_size); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)), - DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User SET frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating User SET frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} -static sl_status_t zwave_command_class_user_credential_user_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) -{ - attribute_store::attribute user_unique_id_node(node); + static sl_status_t zwave_command_class_user_credential_user_get( + attribute_store_node_t node, + uint8_t * frame, + uint16_t * frame_length) + { + attribute_store::attribute user_unique_id_node(node); - // If we enter this state it means that something went badly wrong or - // user initiate the interview process again. - // In both cases we want to invalidate the user database so that the device - // can send us the correct user database. + // If we enter this state it means that something went badly wrong or + // user initiate the interview process again. + // In both cases we want to invalidate the user database so that the device + // can send us the correct user database. - if (!user_unique_id_node.desired_exists()) { - sl_log_warning(LOG_TAG, - "Can't get user unique id Desired value. Removing all users " - "to perform interview again."); - attribute_store::attribute endpoint_node = user_unique_id_node.parent(); + if (!user_unique_id_node.desired_exists()) { + sl_log_warning( + LOG_TAG, + "Can't get user unique id Desired value. Removing all users " + "to perform interview again."); + attribute_store::attribute endpoint_node = user_unique_id_node.parent(); + + // Get User node count + for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + attribute_store_delete_node(user_node); + } - // Get User node count - for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { - attribute_store_delete_node(user_node); + // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. + return SL_STATUS_NOT_SUPPORTED; } - // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. - return SL_STATUS_NOT_SUPPORTED; - } + user_credential_user_unique_id_t user_id + = user_unique_id_node.desired(); + sl_log_debug(LOG_TAG, "User Get for user %d", user_id); - user_credential_user_unique_id_t user_id - = user_unique_id_node.desired(); - sl_log_debug(LOG_TAG, "User Get for user %d", user_id); + // Generate the frame + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_GET_FRAME)); + try { + frame_generator.initialize_frame(USER_GET, frame, expected_frame_size); + frame_generator.add_value(user_unique_id_node, DESIRED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating USER_GET frame : %s", + e.what()); + return SL_STATUS_FAIL; + } - // Generate the frame - constexpr uint8_t expected_frame_size - = static_cast(sizeof(ZW_USER_GET_FRAME)); - try { - frame_generator.initialize_frame(USER_GET, frame, expected_frame_size); - frame_generator.add_value(user_unique_id_node, DESIRED_ATTRIBUTE); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating USER_GET frame : %s", - e.what()); - return SL_STATUS_FAIL; - } + // This special user ID will contains the unaffected credentials. + if (user_id == 0) { + sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); + user_unique_id_node.clear_desired(); + user_unique_id_node.set_reported(user_id); + } - // This special user ID will contains the unaffected credentials. - if (user_id == 0) { - sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); - user_unique_id_node.clear_desired(); - user_unique_id_node.set_reported(user_id); + return SL_STATUS_OK; } - return SL_STATUS_OK; -} - -// TODO : Update with values in ZW_cmdclass.h -enum class user_report_type_t : uint8_t { - USER_ADDED = 0x00, - USER_MODIFIED = 0x01, - USER_DELETED = 0x02, - USER_UNCHANGED = 0x03, - RESPONSE_TO_GET = 0x04, - USER_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, - USER_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, - NON_ZERO_EXPIRING_MINUTES_INVALID = 0x07 -}; + // TODO : Update with values in ZW_cmdclass.h + enum class user_report_type_t : uint8_t { + USER_ADDED = 0x00, + USER_MODIFIED = 0x01, + USER_DELETED = 0x02, + USER_UNCHANGED = 0x03, + RESPONSE_TO_GET = 0x04, + USER_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, + USER_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, + NON_ZERO_EXPIRING_MINUTES_INVALID = 0x07 + }; -sl_status_t zwave_command_class_user_credential_user_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - sl_log_debug(LOG_TAG, "User Report"); + sl_status_t zwave_command_class_user_credential_user_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) + { + sl_log_debug(LOG_TAG, "User Report"); - attribute_store::attribute endpoint_node( - zwave_command_class_get_endpoint_node(connection_info)); + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - const uint8_t expected_min_size = 16; + const uint8_t expected_min_size = 16; - try { - zwave_frame_parser parser(frame_data, frame_length); + try { + zwave_frame_parser parser(frame_data, frame_length); - if (!parser.is_frame_size_valid(expected_min_size, UINT8_MAX)) { - sl_log_error(LOG_TAG, "Invalid frame size for User Report frame"); - return SL_STATUS_FAIL; - } + if (!parser.is_frame_size_valid(expected_min_size, UINT8_MAX)) { + sl_log_error(LOG_TAG, "Invalid frame size for User Report frame"); + return SL_STATUS_FAIL; + } - auto user_report_type = static_cast(parser.read_byte()); + auto user_report_type + = static_cast(parser.read_byte()); - auto next_user_id - = parser.read_sequential(2); + auto next_user_id + = parser.read_sequential(2); - user_credential_modifier_type_t user_modifier_type = parser.read_byte(); - auto user_modifier_id - = parser.read_sequential(2); + user_credential_modifier_type_t user_modifier_type = parser.read_byte(); + auto user_modifier_id + = parser.read_sequential(2); - // Get User ID - auto current_user_id - = parser.read_sequential(2); + // Get User ID + auto current_user_id + = parser.read_sequential(2); - sl_log_debug(LOG_TAG, - "User report for user %d. User report type %d", - current_user_id, - user_report_type); - - // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node - if (current_user_id == 0) { - if (user_report_type == user_report_type_t::RESPONSE_TO_GET) { - sl_log_info(LOG_TAG, "No users was found on the device."); - return SL_STATUS_OK; - } else if (user_report_type == user_report_type_t::USER_DELETED) { - sl_log_info(LOG_TAG, "Request to delete all users"); - - for (auto user_node: - endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { - // Don't delete special user 0 - if (user_node.reported_exists() - && user_node.reported() == 0) { - continue; + sl_log_debug(LOG_TAG, + "User report for user %d. User report type %d", + current_user_id, + user_report_type); + + // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node + if (current_user_id == 0) { + if (user_report_type == user_report_type_t::RESPONSE_TO_GET) { + sl_log_info(LOG_TAG, "No users was found on the device."); + return SL_STATUS_OK; + } else if (user_report_type == user_report_type_t::USER_DELETED) { + sl_log_info(LOG_TAG, "Request to delete all users"); + + for (auto user_node: + endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + // Don't delete special user 0 + if (user_node.reported_exists() + && user_node.reported() + == 0) { + continue; + } + + attribute_store_delete_node(user_node); } - attribute_store_delete_node(user_node); + return SL_STATUS_OK; + } else { + sl_log_error( + LOG_TAG, + "User report with ID 0 received. This is an invalid User " + "Unique Identifier and MUST NOT be used by the node."); + return SL_STATUS_FAIL; } - - return SL_STATUS_OK; - } else { - sl_log_error(LOG_TAG, - "User report with ID 0 received. This is an invalid User " - "Unique Identifier and MUST NOT be used by the node."); - return SL_STATUS_FAIL; } - } - // Lambda function to remove user node in an invalid state - auto remove_current_user_node = [&]() { - get_user_unique_id_node(endpoint_node, current_user_id, DESIRED_ATTRIBUTE) - .delete_node(); - }; + // Lambda function to remove user node in an invalid state + auto remove_current_user_node = [&]() { + get_user_unique_id_node(endpoint_node, + current_user_id, + DESIRED_ATTRIBUTE) + .delete_node(); + }; - // Current user id node that will be used later - // Each report type has a different behavior - attribute_store::attribute current_user_id_node; - switch (user_report_type) { - // Need to create new user node - case user_report_type_t::USER_ADDED: - current_user_id_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - // If this is the first user we get it might not exists yet so we create it. - // Otherwise we just update the reported value - case user_report_type_t::RESPONSE_TO_GET: - current_user_id_node - = create_or_update_desired_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - break; - // We should have a record of given user ID - case user_report_type_t::USER_MODIFIED: - case user_report_type_t::USER_DELETED: - current_user_id_node = get_user_unique_id_node(endpoint_node, - current_user_id, - REPORTED_ATTRIBUTE); - break; - // Special/Errors cases - case user_report_type_t::USER_UNCHANGED: - sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); - return SL_STATUS_OK; - case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: - sl_log_warning(LOG_TAG, - "User %d was not added since it already exists. Try to " - "modify it instead.", - current_user_id); - remove_current_user_node(); - return SL_STATUS_OK; - case user_report_type_t::USER_MODIFY_REJECTED_LOCATION_EMPTY: - sl_log_warning(LOG_TAG, - "User %d was not modified since it doesn't exists. Try " - "to add it instead.", - current_user_id); - remove_current_user_node(); - return SL_STATUS_OK; - case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: - sl_log_warning(LOG_TAG, - "User %d was not modified/added since the expiring " - "timeout minutes is invalid.", - current_user_id); + // Current user id node that will be used later + // Each report type has a different behavior + attribute_store::attribute current_user_id_node; + switch (user_report_type) { + // Need to create new user node + case user_report_type_t::USER_ADDED: + current_user_id_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + // If this is the first user we get it might not exists yet so we create it. + // Otherwise we just update the reported value + case user_report_type_t::RESPONSE_TO_GET: + current_user_id_node + = create_or_update_desired_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + break; + // We should have a record of given user ID + case user_report_type_t::USER_MODIFIED: + case user_report_type_t::USER_DELETED: + current_user_id_node = get_user_unique_id_node(endpoint_node, + current_user_id, + REPORTED_ATTRIBUTE); + break; + // Special/Errors cases + case user_report_type_t::USER_UNCHANGED: + sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); + return SL_STATUS_OK; + case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: + sl_log_warning( + LOG_TAG, + "User %d was not added since it already exists. Try to " + "modify it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::USER_MODIFY_REJECTED_LOCATION_EMPTY: + sl_log_warning( + LOG_TAG, + "User %d was not modified since it doesn't exists. Try " + "to add it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: + sl_log_warning(LOG_TAG, + "User %d was not modified/added since the expiring " + "timeout minutes is invalid.", + current_user_id); + return SL_STATUS_OK; + default: + sl_log_error(LOG_TAG, "Invalid value for user report type."); + return SL_STATUS_FAIL; + }; + + // Deleted special case + if (user_report_type == user_report_type_t::USER_DELETED) { + // TODO : move all credential from this user to user 0 + // Maybe it is done automatically by the credential report + sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); + current_user_id_node.delete_node(); return SL_STATUS_OK; - default: - sl_log_error(LOG_TAG, "Invalid value for user report type."); - return SL_STATUS_FAIL; - }; + } - // Deleted special case - if (user_report_type == user_report_type_t::USER_DELETED) { - // TODO : move all credential from this user to user 0 - // Maybe it is done automatically by the credential report - sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); - current_user_id_node.delete_node(); - return SL_STATUS_OK; - } + // Set already parsed values + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) + .set_reported(user_modifier_type); + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_NODE_ID)) + .set_reported(user_modifier_id); - // Set already parsed values - current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) - .set_reported(user_modifier_type); - current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_NODE_ID)) - .set_reported(user_modifier_id); + // Keep parsing the frame + parser.read_byte(current_user_id_node.emplace_node(ATTRIBUTE(USER_TYPE))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE))}); + parser.read_byte( + current_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE))); + parser.read_sequential( + 2, + current_user_id_node.emplace_node( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING))}); + parser.read_string( + current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME))); - // Keep parsing the frame - parser.read_byte(current_user_id_node.emplace_node(ATTRIBUTE(USER_TYPE))); - parser.read_byte_with_bitmask( - {USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK, - current_user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE))}); - parser.read_byte( - current_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE))); - parser.read_sequential( - 2, - current_user_id_node.emplace_node( - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES))); - parser.read_byte_with_bitmask( - {USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK, - current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING))}); - parser.read_string(current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME))); - - // Get credentials - trigger_get_credential(current_user_id_node, 0, 0); - - if (next_user_id != 0 - && user_report_type == user_report_type_t::RESPONSE_TO_GET) { - if (!user_exists(endpoint_node, next_user_id)) { - sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(next_user_id); + // Get credentials + trigger_get_credential(current_user_id_node, 0, 0); + + if (next_user_id != 0 + && user_report_type == user_report_type_t::RESPONSE_TO_GET) { + if (!user_exists(endpoint_node, next_user_id)) { + sl_log_debug(LOG_TAG, + "Trigger a get for next user (%d)", + next_user_id); + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(next_user_id); + } else { + sl_log_error(LOG_TAG, + "User %d already exists. Not discovering more users.", + next_user_id); + } } else { - sl_log_error(LOG_TAG, - "User %d already exists. Not discovering more users.", - next_user_id); + sl_log_debug(LOG_TAG, "No more users to discover"); } - } else { - sl_log_debug(LOG_TAG, "No more users to discover"); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while parsing User Report frame : %s", - e.what()); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} - -///////////////////////////////////////////////////////////////////////////// -// Checksum helpers -///////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////// + // Checksum helpers + ///////////////////////////////////////////////////////////////////////////// -/** + /** * @brief Compte the checksum and verify the checksum integrity. * * Compare crc16 of checksum_data and expected checksum and put it in the @@ -2292,880 +2232,967 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( * * @return SL_STATUS_OK if checksum is correct, SL_STATUS_FAIL otherwise */ -sl_status_t check_checksum_value(attribute_store::attribute base_node, - attribute_store_type_t checksum_error_type, - user_credential_checksum_t computed_checksum, - user_credential_checksum_t expected_checksum) -{ - sl_status_t status = SL_STATUS_FAIL; + sl_status_t check_checksum_value(attribute_store::attribute base_node, + attribute_store_type_t checksum_error_type, + user_credential_checksum_t computed_checksum, + user_credential_checksum_t expected_checksum) + { + sl_status_t status = SL_STATUS_FAIL; + + if (computed_checksum != expected_checksum) { + sl_log_error(LOG_TAG, + "Checksum mismatch (%s). Expected 0x%X, got 0x%X", + base_node.value_to_string().c_str(), + expected_checksum, + computed_checksum); + base_node.emplace_node(checksum_error_type) + .set_reported(computed_checksum); + } else { + // If we don't have any errors we remove the checksum_error_type node + base_node.child_by_type(checksum_error_type).delete_node(); + status = SL_STATUS_OK; + } - if (computed_checksum != expected_checksum) { - sl_log_error(LOG_TAG, - "Checksum mismatch (%s). Expected 0x%X, got 0x%X", - base_node.value_to_string().c_str(), - expected_checksum, - computed_checksum); - base_node.emplace_node(checksum_error_type).set_reported(computed_checksum); - } else { - // If we don't have any errors we remove the checksum_error_type node - base_node.child_by_type(checksum_error_type).delete_node(); - status = SL_STATUS_OK; + return status; } - return status; -} + ///////////////////////////////////////////////////////////////////////////// + // User Checksum Get/Report + ///////////////////////////////////////////////////////////////////////////// + static sl_status_t zwave_command_class_user_credential_user_checksum_get( + attribute_store_node_t node, + uint8_t * frame, + uint16_t * frame_length) + { + sl_log_debug(LOG_TAG, "User Checksum Get"); + attribute_store::attribute checksum_node(node); -///////////////////////////////////////////////////////////////////////////// -// User Checksum Get/Report -///////////////////////////////////////////////////////////////////////////// -static sl_status_t zwave_command_class_user_credential_user_checksum_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) -{ - sl_log_debug(LOG_TAG, "User Checksum Get"); - attribute_store::attribute checksum_node(node); + auto user_id_node = checksum_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - auto user_id_node = checksum_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + if (!user_id_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Can't find User Unique ID node. Not sending User Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } - if (!user_id_node.is_valid()) { - sl_log_error( - LOG_TAG, - "Can't find User Unique ID node. Not sending User Checksum Get."); - return SL_STATUS_NOT_SUPPORTED; - } + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_CHECKSUM_GET_FRAME)); - constexpr uint8_t expected_frame_size - = static_cast(sizeof(ZW_USER_CHECKSUM_GET_FRAME)); + try { + frame_generator.initialize_frame(USER_CHECKSUM_GET, + frame, + expected_frame_size); + frame_generator.add_value(user_id_node); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User Checksum Get frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } - try { - frame_generator.initialize_frame(USER_CHECKSUM_GET, - frame, - expected_frame_size); - frame_generator.add_value(user_id_node); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating User Checksum Get frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} + sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) + { + sl_status_t result = SL_STATUS_FAIL; -sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - sl_status_t result = SL_STATUS_FAIL; + constexpr uint8_t expected_frame_length + = sizeof(ZW_USER_CHECKSUM_REPORT_FRAME); - constexpr uint8_t expected_frame_length - = sizeof(ZW_USER_CHECKSUM_REPORT_FRAME); + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); - attribute_store::attribute endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + try { + zwave_frame_parser parser(frame_data, frame_length); - try { - zwave_frame_parser parser(frame_data, frame_length); + if (!parser.is_frame_size_valid(expected_frame_length)) { + sl_log_error(LOG_TAG, + "Invalid frame size for User Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } - if (!parser.is_frame_size_valid(expected_frame_length)) { - sl_log_error(LOG_TAG, - "Invalid frame size for User Checksum Report frame"); - return SL_STATUS_NOT_SUPPORTED; - } + // Parse the frame + const auto user_id + = parser.read_sequential(2); + const auto user_checksum + = parser.read_sequential(2); - // Parse the frame - const auto user_id - = parser.read_sequential(2); - const auto user_checksum - = parser.read_sequential(2); - - sl_log_debug(LOG_TAG, - "User Checksum Report. Source User ID: %d / " - "Checksum: 0x%X", - user_id, - user_checksum); - - auto user_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - - user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) - .set_reported(user_checksum); - - // Compute checksum ourselves to see if it matches - user_credential::checksum_calculator checksum_calculator; + sl_log_debug(LOG_TAG, + "User Checksum Report. Source User ID: %d / " + "Checksum: 0x%X", + user_id, + user_checksum); + + auto user_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) + .set_reported(user_checksum); + + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; + + // First gather all the User values + const std::vector user_attributes = { + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME), + }; + for (auto attribute: user_attributes) { + checksum_calculator.add_node(user_node.child_by_type(attribute)); + } - // First gather all the User values - const std::vector user_attributes = { - ATTRIBUTE(USER_TYPE), - ATTRIBUTE(USER_ACTIVE_STATE), - ATTRIBUTE(CREDENTIAL_RULE), - ATTRIBUTE(USER_NAME_ENCODING), - ATTRIBUTE(USER_NAME), - }; - for (auto attribute: user_attributes) { - checksum_calculator.add_node(user_node.child_by_type(attribute)); - } + // The all credential data + for (auto credential_type_node: + user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%d reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } - // The all credential data - for (auto credential_type_node: - user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { - sl_log_debug( - LOG_TAG, - "%d reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); - continue; + // Add credential type to checksum + checksum_calculator.add_node(credential_type_node); + // Add credential slot to checksum + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); } - - // Add credential type to checksum - checksum_calculator.add_node(credential_type_node); - // Add credential slot to checksum - checksum_calculator.add_node(credential_slot_node); - checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); } + + result = check_checksum_value(user_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + user_checksum); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - result = check_checksum_value(user_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), - checksum_calculator.compute_checksum(), - user_checksum); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while parsing User Checksum Report frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + return result; } - return result; -} + ///////////////////////////////////////////////////////////////////////////// + // Credential Checksum Get/Report + ///////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////// -// Credential Checksum Get/Report -///////////////////////////////////////////////////////////////////////////// + static sl_status_t + zwave_command_class_user_credential_credential_checksum_get( + attribute_store_node_t node, + uint8_t * frame, + uint16_t * frame_length) + { + sl_log_debug(LOG_TAG, "Credential Checksum Get"); -static sl_status_t zwave_command_class_user_credential_credential_checksum_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) -{ - sl_log_debug(LOG_TAG, "Credential Checksum Get"); + attribute_store::attribute credential_checksum_node(node); + try { + auto credential_type_node = credential_checksum_node.first_parent( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); - attribute_store::attribute credential_checksum_node(node); - try { - auto credential_type_node = credential_checksum_node.first_parent( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); + if (!credential_type_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find Credential Type node. Not sending Credential " + "Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; + } - if (!credential_type_node.is_valid()) { + frame_generator.initialize_frame( + CREDENTIAL_CHECKSUM_GET, + frame, + sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME)); + + frame_generator.add_value(credential_type_node, REPORTED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { sl_log_error(LOG_TAG, - "Can't find Credential Type node. Not sending Credential " - "Checksum Get."); + "Error while generating Credential Checksum Get frame : %s", + e.what()); return SL_STATUS_NOT_SUPPORTED; } - frame_generator.initialize_frame(CREDENTIAL_CHECKSUM_GET, - frame, - sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME)); - - frame_generator.add_value(credential_type_node, REPORTED_ATTRIBUTE); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating Credential Checksum Get frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} - -sl_status_t - zwave_command_class_user_credential_credential_checksum_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - sl_status_t result = SL_STATUS_FAIL; + sl_status_t + zwave_command_class_user_credential_credential_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) + { + sl_status_t result = SL_STATUS_FAIL; - attribute_store::attribute endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); - constexpr uint8_t expected_frame_length - = sizeof(ZW_CREDENTIAL_CHECKSUM_REPORT_FRAME); - try { - zwave_frame_parser parser(frame_data, frame_length); + constexpr uint8_t expected_frame_length + = sizeof(ZW_CREDENTIAL_CHECKSUM_REPORT_FRAME); + try { + zwave_frame_parser parser(frame_data, frame_length); - if (!parser.is_frame_size_valid(expected_frame_length)) { - sl_log_error(LOG_TAG, - "Invalid frame size for Credential Checksum Report frame"); - return SL_STATUS_NOT_SUPPORTED; - } + if (!parser.is_frame_size_valid(expected_frame_length)) { + sl_log_error(LOG_TAG, + "Invalid frame size for Credential Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; + } - // Parse the frame - const user_credential_type_t credential_type = parser.read_byte(); - const auto credential_checksum - = parser.read_sequential(2); + // Parse the frame + const user_credential_type_t credential_type = parser.read_byte(); + const auto credential_checksum + = parser.read_sequential(2); - sl_log_debug(LOG_TAG, - "Credential Checksum Report. Credential type: %d / " - "Checksum: 0x%X", - credential_type, - credential_checksum); + sl_log_debug(LOG_TAG, + "Credential Checksum Report. Credential type: %d / " + "Checksum: 0x%X", + credential_type, + credential_checksum); - // Get the credential type node - auto credential_type_node = endpoint_node.child_by_type_and_value( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - credential_type); - if (!credential_type_node.is_valid()) { - sl_log_error( - LOG_TAG, - "Can't find Credential Type %d reported by Credential Checksum Report", + // Get the credential type node + auto credential_type_node = endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), credential_type); - return SL_STATUS_FAIL; - } + if (!credential_type_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find Credential Type %d reported by Credential " + "Checksum Report", + credential_type); + return SL_STATUS_FAIL; + } - credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)) - .set_reported(credential_checksum); + credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)) + .set_reported(credential_checksum); - // Compute checksum ourselves to see if it matches - user_credential::checksum_calculator checksum_calculator; - for_each_credential_type_nodes( - endpoint_node, - [&](auto credential_type_node) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { - sl_log_debug( - LOG_TAG, - "%s reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); - continue; + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; + for_each_credential_type_nodes( + endpoint_node, + [&](auto credential_type_node) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%s reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } + + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); } + }, + credential_type); - checksum_calculator.add_node(credential_slot_node); - checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); - } - }, - credential_type); + result + = check_checksum_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + credential_checksum); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } - result = check_checksum_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), - checksum_calculator.compute_checksum(), - credential_checksum); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while parsing Credential Checksum Report frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + return result; } - return result; -} - -///////////////////////////////////////////////////////////////////////////// -// Post interview actions -///////////////////////////////////////////////////////////////////////////// -void zwave_network_status_changed(attribute_store_node_t node, - attribute_store_change_t change) -{ - // We englobe this in case we can't read an attribute or something goes wrong - try { - attribute_store::attribute network_status_node(node); - auto node_id_node = network_status_node.first_parent(ATTRIBUTE_NODE_ID); + ///////////////////////////////////////////////////////////////////////////// + // Post interview actions + ///////////////////////////////////////////////////////////////////////////// + void zwave_network_status_changed(attribute_store_node_t node, + attribute_store_change_t change) + { + // We englobe this in case we can't read an attribute or something goes wrong + try { + attribute_store::attribute network_status_node(node); + auto node_id_node = network_status_node.first_parent(ATTRIBUTE_NODE_ID); - // Should not happen but we check anyway to prevent an exception to raise - if (!node_id_node.reported_exists()) { - return; - } + // Should not happen but we check anyway to prevent an exception to raise + if (!node_id_node.reported_exists()) { + return; + } - auto node_id = node_id_node.reported(); + auto node_id = node_id_node.reported(); - // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything - if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { - return; - } + // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything + if (change == ATTRIBUTE_DELETED + || get_zpc_node_id_node() == node_id_node) { + return; + } - // If the endpoint report is marked as ONLINE_FUNCTIONAL - if (network_status_node.reported() - == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { - sl_log_debug(LOG_TAG, - "Node %d is now ONLINE_FUNCTIONAL : start the delayed " - "interview process", - node_id); - // Perform action on each endpoint that supports User Credential Command class - sl_log_debug(LOG_TAG, "Checking endpoints..."); - for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { - auto endpoint_id = endpoint_node.reported(); - // Check if the endpoint supports User Credential Command class - if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, - node_id, - endpoint_id)) { - sl_log_debug(LOG_TAG, - "Endpoint %d supports User Credential.", - endpoint_id); - auto user_count - = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); - if (user_count == 0) { - sl_log_debug( - LOG_TAG, - "No user found. Starting User and Credential interview"); - // Start the interview process with user ID = 0 - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(0); - } else { + // If the endpoint report is marked as ONLINE_FUNCTIONAL + if (network_status_node.reported() + == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { + sl_log_debug(LOG_TAG, + "Node %d is now ONLINE_FUNCTIONAL : start the delayed " + "interview process", + node_id); + // Perform action on each endpoint that supports User Credential Command class + sl_log_debug(LOG_TAG, "Checking endpoints..."); + for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { + auto endpoint_id = endpoint_node.reported(); + // Check if the endpoint supports User Credential Command class + if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, + node_id, + endpoint_id)) { sl_log_debug(LOG_TAG, - "Users already discovered. No actions needed."); + "Endpoint %d supports User Credential.", + endpoint_id); + auto user_count + = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + if (user_count == 0) { + sl_log_debug( + LOG_TAG, + "No user found. Starting User and Credential interview"); + // Start the interview process with user ID = 0 + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(0); + } else { + sl_log_debug(LOG_TAG, + "Users already discovered. No actions needed."); + } } } + sl_log_debug(LOG_TAG, "Done."); } - sl_log_debug(LOG_TAG, "Done."); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while handling network status change : %s", + e.what()); } - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while handling network status change : %s", - e.what()); } -} - -///////////////////////////////////////////////////////////////////////////// -// Exposed class functions -///////////////////////////////////////////////////////////////////////////// -sl_status_t zwave_command_class_user_credential_add_new_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name) -{ - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); - return SL_STATUS_FAIL; - } + ///////////////////////////////////////////////////////////////////////////// + // Exposed class functions + ///////////////////////////////////////////////////////////////////////////// - // Check if the user already exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); + sl_status_t zwave_command_class_user_credential_add_new_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) + { + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); + return SL_STATUS_FAIL; + } - // Node already exists, can't create user. - if (attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "User with ID %d already exists. Not adding user.", - user_id); - return SL_STATUS_FAIL; - } - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_add_new_user called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); - sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); - sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); - sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); - sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); - sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); - return SL_STATUS_FAIL; - } + // Check if the user already exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); - // Create the user node - user_id_node = attribute_store_emplace_desired(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_TYPE), - &user_type, - sizeof(user_type)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_RULE), - &credential_rule, - sizeof(credential_rule)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_ACTIVE_STATE), - &user_active_state, - sizeof(user_active_state)); - - if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - if (expiring_timeout != 0) { - sl_log_warning( - LOG_TAG, - "Expiring timeout set for non-expiring user, set value to 0."); + // Node already exists, can't create user. + if (attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "User with ID %d already exists. Not adding user.", + user_id); + return SL_STATUS_FAIL; + } + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, + "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; } - expiring_timeout = 0; - } - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - &expiring_timeout, - sizeof(expiring_timeout)); - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_NAME_ENCODING), - &user_name_encoding, - sizeof(user_name_encoding)); - // User name node - auto user_name_node - = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); - attribute_store_set_desired_string(user_name_node, user_name); + // Create the user node + user_id_node = attribute_store_emplace_desired(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_TYPE), + &user_type, + sizeof(user_type)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE), + &credential_rule, + sizeof(credential_rule)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE), + &user_active_state, + sizeof(user_active_state)); + + if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + if (expiring_timeout != 0) { + sl_log_warning( + LOG_TAG, + "Expiring timeout set for non-expiring user, set value to 0."); + } + expiring_timeout = 0; + } - // Finally set operation type add - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); - sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + &user_name_encoding, + sizeof(user_name_encoding)); + // User name node + auto user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); + attribute_store_set_desired_string(user_name_node, user_name); - return SL_STATUS_OK; -} + // Finally set operation type add + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); -sl_status_t zwave_command_class_user_credential_delete_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) -{ - // Check if the user exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); + sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); - // Node doesn't exists, can't delete user. - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "Can't find user with ID %d. Not deleting user.", - user_id); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - // Finally set operation type delete - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) + { + // Check if the user exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); + + // Node doesn't exists, can't delete user. + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "Can't find user with ID %d. Not deleting user.", + user_id); + return SL_STATUS_FAIL; + } - sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); + // Finally set operation type delete + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); - return SL_STATUS_OK; -} + sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); -sl_status_t zwave_command_class_user_credential_modify_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name) -{ - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - // Check if the user already exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); + sl_status_t zwave_command_class_user_credential_modify_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) + { + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); + return SL_STATUS_FAIL; + } - // Node already exists, can't create user. - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, - "User with ID %d doesn't exists. Can't modify user.", - user_id); - return SL_STATUS_FAIL; - } + // Check if the user already exists + attribute_store_node_t user_id_node + = get_reported_user_id_node(endpoint_node, user_id); - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_modify_user called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); - sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); - sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); - sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); - sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); - sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); - return SL_STATUS_FAIL; - } + // Node already exists, can't create user. + if (!attribute_store_node_exists(user_id_node)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Can't modify user.", + user_id); + return SL_STATUS_FAIL; + } - std::map> values = { - {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, - {ATTRIBUTE(CREDENTIAL_RULE), {&credential_rule, sizeof(credential_rule)}}, - {ATTRIBUTE(USER_ACTIVE_STATE), - {&user_active_state, sizeof(user_active_state)}}, - {ATTRIBUTE(USER_NAME_ENCODING), - {&user_name_encoding, sizeof(user_name_encoding)}}, - {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, - }; + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, + "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } - // Only add expiring timeout if user is expiring - if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - {&expiring_timeout, sizeof(expiring_timeout)}}); - } + std::map> values + = { + {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, + {ATTRIBUTE(CREDENTIAL_RULE), + {&credential_rule, sizeof(credential_rule)}}, + {ATTRIBUTE(USER_ACTIVE_STATE), + {&user_active_state, sizeof(user_active_state)}}, + {ATTRIBUTE(USER_NAME_ENCODING), + {&user_name_encoding, sizeof(user_name_encoding)}}, + {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, + }; - // Update values based on the map - sl_status_t status = update_desired_values(user_id_node, values); - // If everything went well set operation type to modify - if (status == SL_STATUS_OK) { - set_user_operation_type(user_id_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); - } else { - sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); - } + // Only add expiring timeout if user is expiring + if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + {&expiring_timeout, sizeof(expiring_timeout)}}); + } - return status; -} + // Update values based on the map + sl_status_t status = update_desired_values(user_id_node, values); + // If everything went well set operation type to modify + if (status == SL_STATUS_OK) { + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); + } else { + sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); + } -sl_status_t zwave_command_class_user_credential_add_new_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char *credential_data) -{ - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_add_new_credential called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - - // Check if parameters are ok - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; + return status; } - auto capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + sl_status_t zwave_command_class_user_credential_add_new_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) + { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Check if parameters are ok + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } - if (!capabilities.is_slot_valid(credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d is not valid. " - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + auto capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists." - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + if (!capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d is not valid. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - // Get or create credential type node - auto credential_type_node - = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - // Process credential data - std::vector credential_data_vector - = capabilities.convert_and_validate_credential_data(credential_data, - credential_slot); + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Get or create credential type node + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + + // Process credential data + std::vector credential_data_vector + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); + + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector, + DESIRED_ATTRIBUTE); + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to add a new credential : %s", + e.what()); + return SL_STATUS_FAIL; + } - auto credential_slot_node - = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot, - DESIRED_ATTRIBUTE); - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), - credential_data_vector, - DESIRED_ATTRIBUTE); - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while trying to add a new credential : %s", - e.what()); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} + sl_status_t zwave_command_class_user_credential_modify_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) + { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Check if parameters are ok + if (user_id == 0 || credential_type == 0 || credential_slot == 0) { + sl_log_error(LOG_TAG, + "User ID, Credential Type and Slot 0 are reserved. Not " + "modifying credentials."); + return SL_STATUS_FAIL; + } -sl_status_t zwave_command_class_user_credential_modify_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char *credential_data) -{ - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_modify_credential called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - - // Check if parameters are ok - if (user_id == 0 || credential_type == 0 || credential_slot == 0) { - sl_log_error(LOG_TAG, - "User ID, Credential Type and Slot 0 are reserved. Not " - "modifying credentials."); - return SL_STATUS_FAIL; + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + // Get current credential slot node + auto credential_slot_node = nodes.slot_node; + // Process credential data + auto capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); + std::vector credential_data_vector + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); + // Modify current data + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) + .set_desired(credential_data_vector); + + // Finally set operation type modify + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to modify a credential : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; } - try { - auto nodes - = get_credential_identifier_nodes(endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); - // Get current credential slot node - auto credential_slot_node = nodes.slot_node; - // Process credential data - auto capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); - std::vector credential_data_vector - = capabilities.convert_and_validate_credential_data(credential_data, - credential_slot); - // Modify current data - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) - .set_desired(credential_data_vector); - - // Finally set operation type modify - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + sl_status_t zwave_command_class_user_credential_delete_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) + { + sl_log_debug(LOG_TAG, + "Delete credential slot %d (credential type %d, user id %d)", + credential_slot, + credential_type, + user_id); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while trying to modify a credential : %s", - e.what()); - return SL_STATUS_FAIL; - } + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); - return SL_STATUS_OK; -} + // Finally set operation type delete + set_credential_operation_type(nodes.slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to delete a credential : %s", + e.what()); + return SL_STATUS_FAIL; + } -sl_status_t zwave_command_class_user_credential_delete_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) -{ - sl_log_debug(LOG_TAG, - "Delete credential slot %d (credential type %d, user id %d)", - credential_slot, - credential_type, - user_id); + return SL_STATUS_OK; + } - try { - auto nodes - = get_credential_identifier_nodes(endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); + sl_status_t zwave_command_class_user_credential_delete_all_users( + attribute_store_node_t endpoint_node) + { + attribute_store::attribute cpp_endpoint_node(endpoint_node); + user_credential_user_unique_id_t user_id = 0; + auto user_id_node + = cpp_endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Finally set operation type delete - set_credential_operation_type(nodes.slot_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while trying to delete a credential : %s", - e.what()); - return SL_STATUS_FAIL; + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, + "Delete all user operation received. Creating user with id %d " + "to send a User SET.", + user_id); + return SL_STATUS_OK; } - return SL_STATUS_OK; -} + void trigger_credential_deletion(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) + { + auto credential_slot_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id) + .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type) + .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), credential_slot); -sl_status_t zwave_command_class_user_credential_delete_all_users( - attribute_store_node_t endpoint_node) -{ - attribute_store::attribute cpp_endpoint_node(endpoint_node); - user_credential_user_unique_id_t user_id = 0; - auto user_id_node - = cpp_endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + // Finally set operation type delete + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); - // Finally set operation type delete - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + sl_log_debug(LOG_TAG, + "Creating user with id %d, credential type %d and slot " + "both to %d to send a Credential SET.", + user_id, + credential_type, + credential_slot); + } - sl_log_debug(LOG_TAG, - "Delete all user operation received. Creating user with id %d " - "to send a User SET.", - user_id); - return SL_STATUS_OK; -} + sl_status_t zwave_command_class_user_credential_delete_all_credentials( + attribute_store_node_t endpoint_node) + { + sl_log_debug(LOG_TAG, "Delete all credential operation received"); -void trigger_credential_deletion(attribute_store::attribute endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) -{ - auto credential_slot_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id) - .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type) - .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), credential_slot); + trigger_credential_deletion(endpoint_node, 0, 0, 0); - // Finally set operation type delete - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); - - sl_log_debug(LOG_TAG, - "Creating user with id %d, credential type %d and slot " - "both to %d to send a Credential SET.", - user_id, - credential_type, - credential_slot); -} + return SL_STATUS_OK; + } -sl_status_t zwave_command_class_user_credential_delete_all_credentials( - attribute_store_node_t endpoint_node) -{ - sl_log_debug(LOG_TAG, "Delete all credential operation received"); + sl_status_t + zwave_command_class_user_credential_delete_all_credentials_by_type( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type) + { + sl_log_debug(LOG_TAG, + "Delete all credential of type %d operation received", + credential_type); - trigger_credential_deletion(endpoint_node, 0, 0, 0); + trigger_credential_deletion(endpoint_node, 0, credential_type, 0); - return SL_STATUS_OK; -} + return SL_STATUS_OK; + } -sl_status_t zwave_command_class_user_credential_delete_all_credentials_by_type( - attribute_store_node_t endpoint_node, user_credential_type_t credential_type) -{ - sl_log_debug(LOG_TAG, - "Delete all credential of type %d operation received", - credential_type); + sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) + { + sl_log_debug(LOG_TAG, + "Delete all credential for user %d operation received", + user_id); - trigger_credential_deletion(endpoint_node, 0, credential_type, 0); + trigger_credential_deletion(endpoint_node, user_id, 0, 0); - return SL_STATUS_OK; -} + return SL_STATUS_OK; + } -sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) -{ - sl_log_debug(LOG_TAG, - "Delete all credential for user %d operation received", - user_id); + sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type) + { + sl_log_debug(LOG_TAG, + "Delete all credential for user %d and credential type %d " + "operation received", + user_id, + credential_type); - trigger_credential_deletion(endpoint_node, user_id, 0, 0); + trigger_credential_deletion(endpoint_node, user_id, credential_type, 0); - return SL_STATUS_OK; -} + return SL_STATUS_OK; + } -sl_status_t - zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + sl_status_t zwave_command_class_user_credential_credential_learn_start_add( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type) -{ - sl_log_debug(LOG_TAG, - "Delete all credential for user %d and credential type %d " - "operation received", - user_id, - credential_type); + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) + { + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (Add)" + " called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); - trigger_credential_deletion(endpoint_node, user_id, credential_type, 0); + auto credential_capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); - return SL_STATUS_OK; -} + if (!credential_capabilities.is_learn_supported()) { + sl_log_error( + LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } -sl_status_t zwave_command_class_user_credential_credential_learn_start_add( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout) -{ - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (Add)" - " called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); + if (!credential_capabilities.is_slot_valid(credential_slot)) { + sl_log_error( + LOG_TAG, + "Credential slot %d is not valid for Credential Type %d. Not " + "starting learn process.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } - if (!credential_capabilities.is_learn_supported()) { - sl_log_error(LOG_TAG, - "Learn is not supported for credential type %d. Not starting " - "learn process.", - credential_type); - return SL_STATUS_FAIL; - } + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - if (!credential_capabilities.is_slot_valid(credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d is not valid for Credential Type %d. Not " - "starting learn process.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + + // Create credential slot with reported value since we don't want + // to trigger a Credential Get right away + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.get_learn_recommended_timeout(); + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } + + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); + + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error in credential learn start : %s", e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; } - // Check parameters values - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( + sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) + { + // Debug info + sl_log_debug( LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; - } + "zwave_command_class_user_credential_credential_learn_start (modify) " + "called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists." - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + auto credential_capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - auto credential_type_node - = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + if (!credential_capabilities.is_learn_supported()) { + sl_log_error( + LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } - // Create credential slot with reported value since we don't want - // to trigger a Credential Get right away - auto credential_slot_node - = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot); + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } if (credential_learn_timeout == 0) { credential_learn_timeout @@ -3176,339 +3203,281 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( credential_learn_timeout); } - // Set attributes for Credential Learn - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) - .set_reported(credential_learn_timeout); - - set_credential_learn_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, "Error in credential learn start : %s", e.what()); - return SL_STATUS_FAIL; - } - - return SL_STATUS_OK; -} - -sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout) -{ - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (modify) " - "called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); - - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + auto credential_slot_node = nodes.slot_node; + + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); + set_credential_learn_operation_type( + credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error in credential learn start modify : %s", + e.what()); + return SL_STATUS_FAIL; + } - if (!credential_capabilities.is_learn_supported()) { - sl_log_error(LOG_TAG, - "Learn is not supported for credential type %d. Not starting " - "learn process.", - credential_type); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - // Check parameters values - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; - } + sl_status_t zwave_command_class_user_credential_credential_learn_stop( + attribute_store_node_t endpoint_node) + { + uint8_t stop_flag = 1; - if (credential_learn_timeout == 0) { - credential_learn_timeout - = credential_capabilities.get_learn_recommended_timeout(); - sl_log_debug(LOG_TAG, - "Credential learn timeout is 0. Setting it to default " - "reported value (%d seconds).", - credential_learn_timeout); + return attribute_store_set_child_desired(endpoint_node, + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &stop_flag, + sizeof(stop_flag)); } - try { - auto nodes - = get_credential_identifier_nodes(endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); - - auto credential_slot_node = nodes.slot_node; - - // Set attributes for Credential Learn - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) - .set_reported(credential_learn_timeout); - set_credential_learn_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error in credential learn start modify : %s", - e.what()); - return SL_STATUS_FAIL; - } - - return SL_STATUS_OK; -} - -sl_status_t zwave_command_class_user_credential_credential_learn_stop( - attribute_store_node_t endpoint_node) -{ - uint8_t stop_flag = 1; - - return attribute_store_set_child_desired(endpoint_node, - ATTRIBUTE(CREDENTIAL_LEARN_STOP), - &stop_flag, - sizeof(stop_flag)); -} - -sl_status_t zwave_command_class_user_credential_uuic_association_set( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type, - user_credential_user_unique_id_t source_user_id, - user_credential_slot_t source_credential_slot, - user_credential_user_unique_id_t destination_user_id, - user_credential_slot_t destination_credential_slot) -{ - try { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {source_user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {source_credential_slot, REPORTED_ATTRIBUTE}); - - nodes.slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)) - .set_desired(destination_user_id); + sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_user_unique_id_t source_user_id, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot) + { + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {source_user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {source_credential_slot, REPORTED_ATTRIBUTE}); + + nodes.slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)) + .set_desired(destination_user_id); + + // Slot ID last since it's this attribute that is bound to the SET command + nodes.slot_node + .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) + .set_desired(destination_credential_slot); + } catch (std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up uuic asociation set : %s", + e.what()); + return SL_STATUS_FAIL; + } - // Slot ID last since it's this attribute that is bound to the SET command - nodes.slot_node - .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) - .set_desired(destination_credential_slot); - } catch (std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up uuic asociation set : %s", - e.what()); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} - -sl_status_t zwave_command_class_user_credential_get_user_checksum( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) -{ - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + sl_status_t zwave_command_class_user_credential_get_user_checksum( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) + { + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + auto checksum_node = user_id_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up user get checksum : %s", + e.what()); + return SL_STATUS_FAIL; + } - auto checksum_node = user_id_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)); - // If node already exists, we clear its value to trigger the GET - checksum_node.clear_reported(); - checksum_node.clear_desired(); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up user get checksum : %s", - e.what()); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} - -sl_status_t zwave_command_class_user_credential_get_credential_checksum( - attribute_store_node_t endpoint_node, user_credential_type_t credential_type) -{ - try { - attribute_store::attribute cpp_endpoint_node(endpoint_node); - auto supported_credential_type_node - = cpp_endpoint_node.child_by_type_and_value( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - credential_type); + sl_status_t zwave_command_class_user_credential_get_credential_checksum( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type) + { + try { + attribute_store::attribute cpp_endpoint_node(endpoint_node); + auto supported_credential_type_node + = cpp_endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + + if (!supported_credential_type_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find supported credential type %d. Not setting up " + "Checksum get.", + credential_type); + return SL_STATUS_FAIL; + } - if (!supported_credential_type_node.is_valid()) { - sl_log_error( - LOG_TAG, - "Can't find supported credential type %d. Not setting up Checksum get.", - credential_type); + auto checksum_node = supported_credential_type_node.emplace_node( + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up credential get checksum : %s", + e.what()); return SL_STATUS_FAIL; } - auto checksum_node = supported_credential_type_node.emplace_node( - ATTRIBUTE(CREDENTIAL_CHECKSUM)); - // If node already exists, we clear its value to trigger the GET - checksum_node.clear_reported(); - checksum_node.clear_desired(); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up credential get checksum : %s", - e.what()); - return SL_STATUS_FAIL; + return SL_STATUS_OK; } - return SL_STATUS_OK; -} + ///////////////////////////////////////////////////////////////////////////// + // Class logic + ///////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////// -// Class logic -///////////////////////////////////////////////////////////////////////////// - -// Control handler -sl_status_t zwave_command_class_user_credential_control_handler( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) -{ - if (frame_length <= COMMAND_INDEX) { - return SL_STATUS_NOT_SUPPORTED; - } - - switch (frame_data[COMMAND_INDEX]) { - case USER_CAPABILITIES_REPORT: - return zwave_command_class_user_credential_user_capabilities_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_CAPABILITIES_REPORT: - return zwave_command_class_user_credential_credential_capabilities_handle_report( - connection_info, - frame_data, - frame_length); - case ALL_USERS_CHECKSUM_REPORT: - return zwave_command_class_user_credential_all_user_checksum_handle_report( - connection_info, - frame_data, - frame_length); - case USER_REPORT: - return zwave_command_class_user_credential_user_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_REPORT: - return zwave_command_class_user_credential_credential_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_LEARN_REPORT: - return zwave_command_class_user_credential_credential_learn_status_report( - connection_info, - frame_data, - frame_length); - case USER_CREDENTIAL_ASSOCIATION_REPORT: - return zwave_command_class_user_credential_uuic_association_report( - connection_info, - frame_data, - frame_length); - case USER_CHECKSUM_REPORT: - return zwave_command_class_user_credential_user_checksum_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_CHECKSUM_REPORT: - return zwave_command_class_user_credential_credential_checksum_handle_report( - connection_info, - frame_data, - frame_length); - default: + // Control handler + sl_status_t zwave_command_class_user_credential_control_handler( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) + { + if (frame_length <= COMMAND_INDEX) { return SL_STATUS_NOT_SUPPORTED; - } -} - -// Entry point -sl_status_t zwave_command_class_user_credential_init() -{ - attribute_store_register_callback_by_type( - &zwave_command_class_user_credential_on_version_attribute_update, - ATTRIBUTE(VERSION)); + } - attribute_resolver_register_rule( - ATTRIBUTE(NUMBER_OF_USERS), - NULL, - &zwave_command_class_user_credential_user_capabilities_get); + switch (frame_data[COMMAND_INDEX]) { + case USER_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_user_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_credential_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case ALL_USERS_CHECKSUM_REPORT: + return zwave_command_class_user_credential_all_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); + case USER_REPORT: + return zwave_command_class_user_credential_user_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_REPORT: + return zwave_command_class_user_credential_credential_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_LEARN_REPORT: + return zwave_command_class_user_credential_credential_learn_status_report( + connection_info, + frame_data, + frame_length); + case USER_CREDENTIAL_ASSOCIATION_REPORT: + return zwave_command_class_user_credential_uuic_association_report( + connection_info, + frame_data, + frame_length); + case USER_CHECKSUM_REPORT: + return zwave_command_class_user_credential_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_CHECKSUM_REPORT: + return zwave_command_class_user_credential_credential_checksum_handle_report( + connection_info, + frame_data, + frame_length); + default: + return SL_STATUS_NOT_SUPPORTED; + } + } - attribute_resolver_register_rule( - ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), - NULL, - &zwave_command_class_user_credential_credential_capabilities_get); - - attribute_resolver_register_rule( - ATTRIBUTE(ALL_USERS_CHECKSUM), - NULL, - &zwave_command_class_user_credential_all_user_checksum_get); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_UNIQUE_ID), - NULL, - &zwave_command_class_user_credential_user_get); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_OPERATION_TYPE), - &zwave_command_class_user_credential_user_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_SLOT), - NULL, - &zwave_command_class_user_credential_credential_get); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &zwave_command_class_user_credential_credential_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - &zwave_command_class_user_credential_credential_learn_start, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_LEARN_STOP), - &zwave_command_class_user_credential_credential_learn_cancel, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), - &zwave_command_class_user_credential_uuic_association_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_CHECKSUM), - NULL, - &zwave_command_class_user_credential_user_checksum_get); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_CHECKSUM), - NULL, - &zwave_command_class_user_credential_credential_checksum_get); - - // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 - // Discussion about delaying the user interview process after the inclusion - - // Proposed Unify-way to delay users get AFTER interview process - attribute_store_register_callback_by_type( - &zwave_network_status_changed, - DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS); - - zwave_command_handler_t handler = {}; - handler.support_handler = NULL; - handler.control_handler = zwave_command_class_user_credential_control_handler; - // CHECKME : Is this right ? - handler.minimal_scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS; - handler.manual_security_validation = false; - handler.command_class = COMMAND_CLASS_USER_CREDENTIAL; - handler.version = 1; - handler.command_class_name = "User Credential"; - handler.comments = "Experimental"; - - return zwave_command_handler_register_handler(handler); -} \ No newline at end of file + // Entry point + sl_status_t zwave_command_class_user_credential_init() + { + attribute_store_register_callback_by_type( + &zwave_command_class_user_credential_on_version_attribute_update, + ATTRIBUTE(VERSION)); + + attribute_resolver_register_rule( + ATTRIBUTE(NUMBER_OF_USERS), + NULL, + &zwave_command_class_user_credential_user_capabilities_get); + + attribute_resolver_register_rule( + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_capabilities_get); + + attribute_resolver_register_rule( + ATTRIBUTE(ALL_USERS_CHECKSUM), + NULL, + &zwave_command_class_user_credential_all_user_checksum_get); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_UNIQUE_ID), + NULL, + &zwave_command_class_user_credential_user_get); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_OPERATION_TYPE), + &zwave_command_class_user_credential_user_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_SLOT), + NULL, + &zwave_command_class_user_credential_credential_get); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_learn_start, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &zwave_command_class_user_credential_credential_learn_cancel, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + &zwave_command_class_user_credential_uuic_association_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_CHECKSUM), + NULL, + &zwave_command_class_user_credential_user_checksum_get); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_checksum_get); + + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 + // Discussion about delaying the user interview process after the inclusion + + // Proposed Unify-way to delay users get AFTER interview process + attribute_store_register_callback_by_type( + &zwave_network_status_changed, + DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS); + + zwave_command_handler_t handler = {}; + handler.support_handler = NULL; + handler.control_handler + = zwave_command_class_user_credential_control_handler; + // CHECKME : Is this right ? + handler.minimal_scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS; + handler.manual_security_validation = false; + handler.command_class = COMMAND_CLASS_USER_CREDENTIAL; + handler.version = 1; + handler.command_class_name = "User Credential"; + handler.comments = "Experimental"; + + return zwave_command_handler_register_handler(handler); + } \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index d1892a100..f761bba5d 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -259,7 +259,8 @@ void helper_simulate_association_report_frame( user_credential_slot_t source_credential_slot, user_credential_user_unique_id_t destination_user_id, user_credential_slot_t destination_credential_slot, - uint8_t credential_association_status) + uint8_t credential_association_status, + sl_status_t expected_status = SL_STATUS_OK) { zwave_frame report_frame; @@ -270,7 +271,9 @@ void helper_simulate_association_report_frame( report_frame.add(destination_credential_slot); report_frame.add(credential_association_status); - helper_test_report_frame(USER_CREDENTIAL_ASSOCIATION_REPORT, report_frame); + helper_test_report_frame(USER_CREDENTIAL_ASSOCIATION_REPORT, + report_frame, + expected_status); } void helper_test_credential_learn_structure( @@ -3264,12 +3267,10 @@ void test_user_credential_uuic_association_same_slot_different_user() destination_credential_slot, association_status); + // Test data structure TEST_ASSERT_TRUE_MESSAGE(source_nodes.credential_type_node.is_valid(), "Old credential type node should still exist"); - TEST_ASSERT_FALSE_MESSAGE( - source_nodes.credential_slot_node.is_valid(), - "Old credential slot node should have been removed"); // Association nodes doesn't have any reported value so they shouldn't exists anymore TEST_ASSERT_FALSE_MESSAGE( association_nodes.association_user_id_node.is_valid(), @@ -3288,12 +3289,18 @@ void test_user_credential_uuic_association_same_slot_different_user() = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), credential_type, destination_user_id_node); + TEST_ASSERT_EQUAL_MESSAGE( + source_nodes.credential_slot_node.parent(), + destination_credential_type_node, + "Old credential slot node should have new parent"); auto destination_credential_slot_node = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), destination_credential_slot, destination_credential_type_node); + + helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); @@ -3379,9 +3386,6 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex // Test data structure TEST_ASSERT_TRUE_MESSAGE(source_nodes.credential_type_node.is_valid(), "Old credential type node should still exist"); - TEST_ASSERT_FALSE_MESSAGE( - source_nodes.credential_slot_node.is_valid(), - "Old credential slot node should have been removed"); // Association nodes doesn't have any reported value so they shouldn't exists anymore TEST_ASSERT_FALSE_MESSAGE( association_nodes.association_user_id_node.is_valid(), @@ -3401,6 +3405,11 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex credential_type, destination_user_id_node); + TEST_ASSERT_EQUAL_MESSAGE( + source_nodes.credential_slot_node.parent(), + destination_credential_type_node, + "Old credential slot node should have new parent"); + auto destination_credential_slot_node = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), destination_credential_slot, @@ -3597,7 +3606,7 @@ void test_user_credential_uuic_association_error_code() "Old credential type node should still exist"); TEST_ASSERT_TRUE_MESSAGE( attribute_store_node_exists(source_nodes.credential_slot_node), - "Old credential slot node should have been removed"); + "Old credential slot node should still exists"); // Association nodes doesn't have any reported value so they shouldn't exists anymore TEST_ASSERT_FALSE_MESSAGE( attribute_store_node_exists(association_nodes.association_user_id_node), From b90907570241b48117b968f68b1ec9cbfc9bb7c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 3 Sep 2024 12:15:36 +0200 Subject: [PATCH 38/60] UIC-3222: Remove deprecated functions --- .../zwave_command_class_user_credential.cpp | 379 ++++-------------- 1 file changed, 74 insertions(+), 305 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index bc0d85509..14a00c8fe 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -88,18 +88,6 @@ struct credential_id_nodes { attribute_store::attribute user_unique_id_node; }; -///////////////////////////////////////////////////////////////////////////// -// Type Helpers -///////////////////////////////////////////////////////////////////////////// -uint16_t get_uint16_value(const uint8_t *frame, uint16_t start_index) -{ - uint16_t extracted_value = 0; - for (int i = 0; i < 2; i++) { - extracted_value = (extracted_value << 8) | frame[start_index + i]; - } - - return extracted_value; -} ///////////////////////////////////////////////////////////////////////////// // Command Class Helper @@ -138,120 +126,77 @@ template attribute_store::attribute return node; } -void set_operation_type(attribute_store_node_t node, +/** + * @brief Create operation_type_node_type if it doesn't exists, and set the desired value to operation_type (and clear reported) + * + * @see set_user_operation_type + * @see set_credential_operation_type + * @see set_credential_learn_operation_type + * + * @param base_node Base node to search for the attribute + * @param operation_type_node_type Type of the operation type node + * @param operation_type Operation type to set + * + */ +void set_operation_type(attribute_store::attribute base_node, attribute_store_type_t operation_type_node_type, user_credential_operation_type_t operation_type) { - auto operation_type_node - = attribute_store_get_node_child_by_type(node, operation_type_node_type, 0); + auto operation_type_node = base_node.emplace_node(operation_type_node_type); - if (!attribute_store_node_exists(operation_type_node)) { - operation_type_node - = attribute_store_add_node(operation_type_node_type, node); - } // Undefine reported to be sure that we can so the same operation twice in a row - attribute_store_undefine_reported(operation_type_node); - attribute_store_set_desired(operation_type_node, - &operation_type, - sizeof(operation_type)); -} -void set_user_operation_type(attribute_store_node_t user_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(user_node, ATTRIBUTE(USER_OPERATION_TYPE), operation_type); -} - -void set_credential_operation_type( - attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - operation_type); -} - -void set_credential_learn_operation_type( - attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - operation_type); + operation_type_node.clear_reported(); + operation_type_node.set_desired(operation_type); } /** - * @brief Get user id node + * @brief Set User Operation * - * @deprecated + * Set the operation type as desired and clear reported to call SET function * - * @warning state can't be DESIRED_OR_REPORTED_ATTRIBUTE or it will not work + * @param user_node User node + * @param operation_type Operation type to set * - * @param endpoint_node Endpoint point node - * @param user_id User ID to find - * @param state Check reported or desired value. - * @param user_id_node User id node will be stored here if found - * - * @return true User id exists - * @return false User id doesn't exists */ -bool get_user_id_node(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - attribute_store_node_value_state_t state, - attribute_store_node_t &user_id_node) +void set_user_operation_type(attribute_store_node_t user_node, + user_credential_operation_type_t operation_type) { - user_id_node - = attribute_store_get_node_child_by_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - state, - (uint8_t *)&user_id, - sizeof(user_id), - 0); - - return attribute_store_node_exists(user_id_node); + set_operation_type(user_node, ATTRIBUTE(USER_OPERATION_TYPE), operation_type); } /** - * @brief Get node associated with user ID (reported) + * @brief Set Credential Operation * - * @deprecated + * Set the operation type as desired and clear reported to call SET function * - * @warning This function only checks the reported User Unique + * @param slot_node Slot node + * @param operation_type Operation type to set * - * @param endpoint_node Current endpoint node - * @param user_id User ID - * - * @return attribute_store_node_t If User ID exists - * @return INVALID_ATTRIBUTE_STORE_NODE If User ID does not exist */ -attribute_store_node_t - get_reported_user_id_node(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) +void set_credential_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) { - attribute_store_node_t user_id_node; - get_user_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE, user_id_node); - return user_id_node; + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type); } /** - * @brief Get node associated with user ID (desired) + * @brief Set Credential Learn Operation * - * @warning This function only checks the reported User Unique + * Set the operation type as desired and clear reported to call SET function * - * @deprecated - * - * @param endpoint_node Current endpoint node - * @param user_id User ID - * - * @return attribute_store_node_t If User ID exists - * @return INVALID_ATTRIBUTE_STORE_NODE If User ID does not exist + * @param slot_node Slot node + * @param operation_type Operation type to set */ -attribute_store_node_t - get_desired_user_id_node(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) +void set_credential_learn_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) { - attribute_store_node_t user_id_node; - get_user_id_node(endpoint_node, user_id, DESIRED_ATTRIBUTE, user_id_node); - return user_id_node; + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + operation_type); } /** @@ -376,104 +321,6 @@ attribute_store::attribute return cred_slot_node; } -/** - * @brief Get credential node associated with credential_type and user_id. - * - * @deprecated - * - * @param endpoint_node Current endpoint node - * @param user_id User ID - * @param credential_type Credential type - * @param state Check reported or desired value. - * @param credential_type_node Credential node will be stored here if found - * - * @return true Credential Type exists - * @return false Credential Type doesn't exists - */ -bool get_credential_type_node(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - attribute_store_node_value_state_t state, - attribute_store_node_t &credential_type_node) -{ - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); - - credential_type_node - = attribute_store_get_node_child_by_value(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - state, - (uint8_t *)&credential_type, - sizeof(credential_type), - 0); - - return attribute_store_node_exists(credential_type_node); -} - -/** - * @brief Get ALL the credential type nodes. - * - * By default it will return all the credential type nodes, but you can narrow - * to a specific credential type with the credential_type parameter - * - * @deprecated Use for_each_credential_type_nodes instead - * - * @param endpoint_node Endpoint point node - * @param credential_type Credential type to find. If 0, will return all credential types - * - * @return std::vector List of credential type nodes -*/ -std::vector - get_all_credential_type_nodes(attribute_store_node_t endpoint_node, - user_credential_type_t credential_type = 0) -{ - std::vector credential_type_nodes; - - // Delete all user nodes - auto user_node_count - = attribute_store_get_node_child_count_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID)); - - for (size_t user_id_index = 0; user_id_index < user_node_count; - user_id_index++) { - attribute_store_node_t user_node - = attribute_store_get_node_child_by_type(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - user_id_index); - - auto credential_type_node_count - = attribute_store_get_node_child_count_by_type( - user_node, - ATTRIBUTE(CREDENTIAL_TYPE)); - - for (size_t credential_index = 0; - credential_index < credential_type_node_count; - credential_index++) { - attribute_store_node_t credential_type_node - = attribute_store_get_node_child_by_type(user_node, - ATTRIBUTE(CREDENTIAL_TYPE), - credential_index); - if (credential_type == 0) { - // If we haven't specify a node type we take them all - credential_type_nodes.push_back(credential_type_node); - } else { - // Otherwise we only take the ones that match - user_credential_type_t current_credential_type; - attribute_store_read_value(credential_type_node, - REPORTED_ATTRIBUTE, - ¤t_credential_type, - sizeof(current_credential_type)); - - if (current_credential_type == credential_type) { - credential_type_nodes.push_back(credential_type_node); - } - } - } - } - - return credential_type_nodes; -} - /** * @brief Iterate on each credential type nodes for a given user * @@ -518,35 +365,6 @@ void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, } } -/** - * @brief Get credential slot node - * - * @warning state can't be DESIRED_OR_REPORTED_ATTRIBUTE or it will not work - * - * @param credential_type_node Endpoint point node - * @param credential_slot Credential Slot to find - * @param state Check reported or desired value. - * @param credential_slot_node Credential Slot node will be stored here if found - * - * @return true Credential Slot exists - * @return false Credential Slot doesn't exists - */ -bool get_credential_slot_node(attribute_store_node_t credential_type_node, - user_credential_slot_t credential_slot, - attribute_store_node_value_state_t state, - attribute_store_node_t &credential_slot_node) -{ - credential_slot_node - = attribute_store_get_node_child_by_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - state, - (uint8_t *)&credential_slot, - sizeof(credential_slot), - 0); - - return attribute_store_node_exists(credential_slot_node); -} - /** * @brief Checks if given credential ID (credential type, credential slot) is available * @@ -561,69 +379,26 @@ bool is_credential_available(attribute_store_node_t endpoint_node, user_credential_type_t credential_type, user_credential_slot_t credential_slot) { - auto credential_type_nodes - = get_all_credential_type_nodes(endpoint_node, credential_type); - - // Credential type, Credential Node pair is Unique - for (auto &credential_type_node: credential_type_nodes) { - user_credential_type_t current_type; - attribute_store_get_reported(credential_type_node, - ¤t_type, - sizeof(current_type)); - user_credential_slot_t current_slot; - attribute_store_get_child_reported(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - ¤t_slot, - sizeof(current_slot)); - if (current_slot == credential_slot && current_type == credential_type) { - return false; - } - } + bool credential_available = true; - return true; -} + for_each_credential_type_nodes(endpoint_node, [&](attribute_store::attribute &credential_type_node) { + for (auto &credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { -/** - * @brief Add credential type node to given user if it doesn't exists. - * - * @param endpoint_node Endpoint node - * @param user_id User ID. Must exists. - * @param credential_type Credential type - * - * @return attribute_store_node_t Credential type node (with desired value if it doesn't exists, or the existant one) - * @return ATTRIBUTE_STORE_INVALID_NODE If an error occurred - **/ -attribute_store_node_t - add_credential_type_node_if_missing(attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type) -{ - attribute_store_node_t credential_type_node = ATTRIBUTE_STORE_INVALID_NODE; - - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); - - if (!attribute_store_node_exists(user_id_node)) { - sl_log_error(LOG_TAG, "User ID %d doesn't exists", user_id); - return credential_type_node; - } - - // First check Credential Type existence - get_credential_type_node(endpoint_node, - user_id, - credential_type, - REPORTED_ATTRIBUTE, - credential_type_node); - if (!attribute_store_node_exists(credential_type_node)) { - // Create Credential Type if it doesn't exists - credential_type_node - = attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - &credential_type, - sizeof(credential_type)); - } + // If this credential slot node doesn't have a reported value, check the next one + if (!credential_slot_node.reported_exists()) { + continue; + } - return credential_type_node; + if (credential_slot_node.reported() + == credential_slot) { + credential_available = false; + return; + } + } + }, credential_type); + + return credential_available; } /** @@ -1872,7 +1647,7 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( } ///////////////////////////////////////////////////////////////////////////// - // User Set/Get/Report/Set Error Report + // User Set/Get/Report ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_user_set( @@ -2598,17 +2373,14 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( return SL_STATUS_FAIL; } - // Check if the user already exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); - // Node already exists, can't create user. - if (attribute_store_node_exists(user_id_node)) { + if (user_exists(endpoint_node, user_id)) { sl_log_error(LOG_TAG, "User with ID %d already exists. Not adding user.", user_id); return SL_STATUS_FAIL; } + // Debug info sl_log_debug( LOG_TAG, @@ -2633,7 +2405,7 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( } // Create the user node - user_id_node = attribute_store_emplace_desired(endpoint_node, + auto user_id_node = attribute_store_emplace_desired(endpoint_node, ATTRIBUTE(USER_UNIQUE_ID), &user_id, sizeof(user_id)); @@ -2688,18 +2460,16 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id) { - // Check if the user exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); - - // Node doesn't exists, can't delete user. - if (!attribute_store_node_exists(user_id_node)) { + if (!user_exists(endpoint_node, user_id)) { sl_log_error(LOG_TAG, - "Can't find user with ID %d. Not deleting user.", + "User with ID %d doesn't exists. Not deleting user.", user_id); return SL_STATUS_FAIL; } + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Finally set operation type delete set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); @@ -2725,18 +2495,17 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( return SL_STATUS_FAIL; } - // Check if the user already exists - attribute_store_node_t user_id_node - = get_reported_user_id_node(endpoint_node, user_id); - - // Node already exists, can't create user. - if (!attribute_store_node_exists(user_id_node)) { + if (!user_exists(endpoint_node, user_id)) { sl_log_error(LOG_TAG, "User with ID %d doesn't exists. Can't modify user.", user_id); return SL_STATUS_FAIL; } + // Check if the user already exists + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Debug info sl_log_debug( LOG_TAG, From 7831d9145cf1157d15a418468192042235817aaa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 3 Sep 2024 13:57:02 +0200 Subject: [PATCH 39/60] UIC-3222: Move user credential helpers into their own files --- .../user_credential_checksum_calculator.cpp | 9 +- ...ser_credential_credential_capabilities.cpp | 8 +- .../user_credential_definitions.hpp | 26 + .../user_credential_helpers.hpp | 456 ++++++++++++++++++ .../user_credential_user_capabilities.cpp | 6 +- .../zwave_command_class_user_credential.cpp | 430 +---------------- 6 files changed, 493 insertions(+), 442 deletions(-) create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_definitions.hpp create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp index 2b6c5c7f2..f272038f8 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp @@ -10,13 +10,14 @@ * sections of the MSLA applicable to Source Code. * *****************************************************************************/ - +// Base class #include "user_credential_checksum_calculator.h" +// CRC 16 #include "zwave_controller_crc16.h" -// Log -#include "sl_log.h" +// Common definitions +#include "user_credential_definitions.hpp" namespace user_credential { @@ -25,8 +26,6 @@ namespace user_credential constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; constexpr uint8_t MAX_CHAR_SIZE = 64; -constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; - std::vector get_raw_data_from_node(const attribute_store::attribute &node) { diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp index 024f8c84b..b70fbbf3c 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp @@ -16,9 +16,6 @@ // Get attribute store names #include "attribute_store_defined_attribute_types.h" -// Log -#include "sl_log.h" - // UTF16 conversion (deprecated in C++17 but we don't have a better alternative yet) // Needed for credential data (password) per specification #include @@ -27,13 +24,12 @@ // Boost #include -#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type +// Common definitions +#include "user_credential_definitions.hpp" namespace user_credential { -constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; - credential_capabilities::credential_capabilities( const attribute_store::attribute &endpoint_node, user_credential_type_t credential_type) diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_definitions.hpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_definitions.hpp new file mode 100644 index 000000000..a30eccc9f --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_definitions.hpp @@ -0,0 +1,26 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#ifndef USER_CREDENTIAL_DEFINITIONS_HPP +#define USER_CREDENTIAL_DEFINITIONS_HPP + +// Log +#include "sl_log.h" + +#ifndef ATTRIBUTE +#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type +#endif + +constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; + +#endif // USER_CREDENTIAL_DEFINITIONS_HPP \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp new file mode 100644 index 000000000..7ae0b07ff --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp @@ -0,0 +1,456 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#ifndef USER_CREDENTIAL_HELPERS_H +#define USER_CREDENTIAL_HELPERS_H + +// Get attribute store names +#include "attribute_store_defined_attribute_types.h" +// User credential types +#include "zwave_command_class_user_credential_types.h" + +// Cpp +#include "attribute.hpp" +#include "boost/format.hpp" + +#include "user_credential_definitions.hpp" + +namespace user_credential_helpers +{ + +using attribute_callback = std::function; + +///////////////////////////////////////////////////////////////////////////// +// Data struct +///////////////////////////////////////////////////////////////////////////// + +// Represent a credential ID (slot, type, user unique ID) +struct credential_id_nodes { + attribute_store::attribute slot_node; + attribute_store::attribute type_node; + attribute_store::attribute user_unique_id_node; +}; + +/** + * @brief Update desired value if found, or create the node otherwise + * + * Check for the value in the desired value of attribute_type (with parent base_node). + * If we found it, we update the reported value and clear the desired value. + * Otherwise we create the node with the given value and set it to reported. + * + * @tparam T Type of the value to set + * + * @param base_node Base node to search for the attribute + * @param attribute_type Type of the attribute to search for + * @param value Value to search/set + * + * @return attribute_store::attribute Node that was created/updated + */ +template attribute_store::attribute + create_or_update_desired_value(attribute_store::attribute base_node, + attribute_store_type_t attribute_type, + T value) +{ + auto node = base_node.child_by_type_and_value(attribute_type, + value, + DESIRED_ATTRIBUTE); + if (!node.is_valid()) { + node = base_node.emplace_node(attribute_type, value); + } else { + node.set_reported(value); + node.clear_desired(); + } + + return node; +} + +/** + * @brief Create operation_type_node_type if it doesn't exists, and set the desired value to operation_type (and clear reported) + * + * @see set_user_operation_type + * @see set_credential_operation_type + * @see set_credential_learn_operation_type + * + * @param base_node Base node to search for the attribute + * @param operation_type_node_type Type of the operation type node + * @param operation_type Operation type to set + * + */ +void set_operation_type(attribute_store::attribute base_node, + attribute_store_type_t operation_type_node_type, + user_credential_operation_type_t operation_type) +{ + auto operation_type_node = base_node.emplace_node(operation_type_node_type); + + // Undefine reported to be sure that we can so the same operation twice in a row + operation_type_node.clear_reported(); + operation_type_node.set_desired(operation_type); +} + +/** + * @brief Set User Operation + * + * Set the operation type as desired and clear reported to call SET function + * + * @param user_node User node + * @param operation_type Operation type to set + * + */ +void set_user_operation_type(attribute_store_node_t user_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type( + user_node, + ATTRIBUTE(USER_OPERATION_TYPE), + operation_type); +} + +/** + * @brief Set Credential Operation + * + * Set the operation type as desired and clear reported to call SET function + * + * @param slot_node Slot node + * @param operation_type Operation type to set + * + */ +void set_credential_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type); +} + +/** + * @brief Set Credential Learn Operation + * + * Set the operation type as desired and clear reported to call SET function + * + * @param slot_node Slot node + * @param operation_type Operation type to set + */ +void set_credential_learn_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + operation_type); +} + +/** + * @brief Get node associated with user ID (desired or reported) + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * + * @return True is user exists, false otherwise + */ +bool user_exists(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id) +{ + return endpoint_node + .child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + REPORTED_ATTRIBUTE) + .is_valid(); +} + +/** + * @brief Get node associated with user ID (desired or reported) + * + * @param endpoint_node Current endpoint node + * @param user_id User ID + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If User ID does not exist with given state + * + * @return User ID Node + */ +attribute_store::attribute + get_user_unique_id_node(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id, + attribute_store_node_value_state_t state) +{ + attribute_store::attribute user_id_node + = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + state); + + if (!user_id_node.is_valid()) { + throw std::runtime_error( + (boost::format("User ID %1% not found (state : %2%).") % user_id % state) + .str()); + } + + return user_id_node; +} + +/** + * @brief Get credential type node associated with user ID + * + * @param user_id_node User ID node + * @param cred_type Credential type + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If Credential type for given user_id_node does not exist with given state + * + * @return Credential type node + */ +attribute_store::attribute + get_credential_type_node(attribute_store::attribute user_id_node, + user_credential_type_t cred_type, + attribute_store_node_value_state_t state) +{ + if (!user_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_type_node: User ID node is not valid."); + } + + attribute_store::attribute cred_type_node + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + cred_type, + state); + + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + (boost::format("Credential type %1% (state : %2%) not found for %3%.") + % cred_type % state % user_id_node.value_to_string()) + .str()); + } + + return cred_type_node; +} + +/** + * @brief Get credential slot node associated with credential type + * + * @param cred_type_node Credential type node + * @param cred_slot Credential slot + * @param state Check reported or desired value (or desired else reported) + * + * @throws std::runtime_error If Credential slot for given cred_type_node does not exist with given state + * + * @return Credential slot node + */ +attribute_store::attribute + get_credential_slot_node(attribute_store::attribute cred_type_node, + user_credential_slot_t cred_slot, + attribute_store_node_value_state_t state) +{ + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + "get_credential_slot_node: Credential Type node is not valid."); + } + + attribute_store::attribute cred_slot_node + = cred_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), + cred_slot, + state); + + if (!cred_slot_node.is_valid()) { + throw std::runtime_error( + (boost::format( + "Credential slot %1% (state : %2%) not found for %3% / %4%.") + % cred_slot % state % cred_type_node.value_to_string() + % cred_type_node.parent().value_to_string()) + .str()); + } + + return cred_slot_node; +} + +/** + * @brief Iterate on each credential type nodes for a given user + * + * @param user_id_node User ID node + * @param callback Callback function to call for each credential type node + * @param credential_type Credential type to find. If 0, process all credential types + */ +void for_each_credential_type_nodes_for_user( + attribute_store::attribute user_id_node, + const attribute_callback &callback, + user_credential_type_t credential_type = 0) +{ + auto credential_type_nodes + = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); + for (auto &credential_type_node: credential_type_nodes) { + // Call + if (credential_type == 0 + || (credential_type_node.reported_exists() + && credential_type_node.reported() + == credential_type)) { + callback(credential_type_node); + } + } +} + +/** + * @brief Iterate on each credential type nodes + * + * @param endpoint_node Endpoint point node + * @param callback Callback function to call for each credential type node + * @param credential_type Credential type to find. If 0, process all credential types + */ +void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, + const attribute_callback &callback, + user_credential_type_t credential_type = 0) +{ + auto user_nodes = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)); + for (auto &user_node: user_nodes) { + for_each_credential_type_nodes_for_user(user_node, + callback, + credential_type); + } +} + +/** + * @brief Checks if given credential ID (credential type, credential slot) is available + * + * @param endpoint_node Endpoint node + * @param credential_type Credential type + * @param credential_slot Credential slot + * + * @return true Credential is available + * @return false Credential is not available : if an user already have the combination of given credential type and slot. +*/ +bool is_credential_available(attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + bool credential_available = true; + + for_each_credential_type_nodes( + endpoint_node, + [&](attribute_store::attribute &credential_type_node) { + for (auto &credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + // If this credential slot node doesn't have a reported value, check the next one + if (!credential_slot_node.reported_exists()) { + continue; + } + + if (credential_slot_node.reported() + == credential_slot) { + credential_available = false; + return; + } + } + }, + credential_type); + + return credential_available; +} + +/** + * @brief Get associated credential identifier nodes + * + * @param child_node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents + * + * @throws std::runtime_error If one of the nodes is not found + * + * @return credential_id_nodes Credential identifier nodes + */ +credential_id_nodes + get_credential_identifier_nodes(attribute_store_node_t child_node) +{ + attribute_store::attribute slot_node(child_node); + slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store::attribute type_node + = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); + attribute_store::attribute user_unique_id_node + = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + if (!slot_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential slot node."); + } + + if (!type_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential type node."); + } + + if (!user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID node."); + } + + return {.slot_node = slot_node, + .type_node = type_node, + .user_unique_id_node = user_unique_id_node}; +} + +template struct identifier_state { + T value; + attribute_store_node_value_state_t state; +}; +/** + * @brief Get associated credential identifier nodes + * + * @param endpoint_node Endpoint node + * @param user_id User ID with given state + * @param credential_type Credential type with given state + * @param credential_slot Credential slot with given state + * + * @throws std::runtime_error If one of the nodes is not found + * + * @return credential_id_nodes Credential identifier nodes + */ +credential_id_nodes get_credential_identifier_nodes( + const attribute_store::attribute &endpoint_node, + identifier_state user_id, + identifier_state credential_type, + identifier_state credential_slot) +{ + credential_id_nodes nodes; + + nodes.user_unique_id_node + = get_user_unique_id_node(endpoint_node, user_id.value, user_id.state); + + if (!nodes.user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID " + + std::to_string(user_id.value)); + } + + nodes.type_node = get_credential_type_node(nodes.user_unique_id_node, + credential_type.value, + credential_type.state); + + if (!nodes.type_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "type %1% for user %2%") + % credential_type.value % user_id.value) + .str()); + } + + nodes.slot_node = get_credential_slot_node(nodes.type_node, + credential_slot.value, + credential_slot.state); + + if (!nodes.slot_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "slot %1% for credential type %2% / user %3%") + % credential_slot.value % credential_type.value % user_id.value) + .str()); + } + return nodes; +} + +} // namespace user_credential +#endif // USER_CREDENTIAL_HELPERS_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp index 19bedddd9..4e30d205f 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp @@ -16,15 +16,13 @@ // Get attribute store names #include "attribute_store_defined_attribute_types.h" -// Log -#include "sl_log.h" +// Common definitions +#include "user_credential_definitions.hpp" -#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type namespace user_credential { -constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; user_capabilities::user_capabilities(attribute_store::attribute endpoint_node) { try { diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 14a00c8fe..cf93225d5 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -32,7 +32,6 @@ #include "attribute_store.h" #include "attribute_store_helper.h" #include "attribute_store_type_registration.h" -#include "sl_log.h" // DotDot #include "unify_dotdot_attribute_store_node_state.h" @@ -49,18 +48,14 @@ #include "zwave_frame_parser.hpp" // Private helpers +#include "private/user_credential/user_credential_definitions.hpp" #include "private/user_credential/user_credential_user_capabilities.h" #include "private/user_credential/user_credential_credential_capabilities.h" #include "private/user_credential/user_credential_checksum_calculator.h" - -// Macro -#define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type - -// Constexpr -constexpr char LOG_TAG[] = "zwave_command_class_user_credential"; +#include "private/user_credential/user_credential_helpers.hpp" // Using -using attribute_callback = std::function; +using namespace user_credential_helpers; /** * @brief Implementation notes @@ -78,426 +73,7 @@ namespace zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); } -///////////////////////////////////////////////////////////////////////////// -// Data struct -///////////////////////////////////////////////////////////////////////////// -// Represent a credential ID (slot, type, user unique ID) -struct credential_id_nodes { - attribute_store::attribute slot_node; - attribute_store::attribute type_node; - attribute_store::attribute user_unique_id_node; -}; - - -///////////////////////////////////////////////////////////////////////////// -// Command Class Helper -///////////////////////////////////////////////////////////////////////////// - -/** - * @brief Update desired value if found, or create the node otherwise - * - * Check for the value in the desired value of attribute_type (with parent base_node). - * If we found it, we update the reported value and clear the desired value. - * Otherwise we create the node with the given value and set it to reported. - * - * @tparam T Type of the value to set - * - * @param base_node Base node to search for the attribute - * @param attribute_type Type of the attribute to search for - * @param value Value to search/set - * - * @return attribute_store::attribute Node that was created/updated - */ -template attribute_store::attribute - create_or_update_desired_value(attribute_store::attribute base_node, - attribute_store_type_t attribute_type, - T value) -{ - auto node = base_node.child_by_type_and_value(attribute_type, - value, - DESIRED_ATTRIBUTE); - if (!node.is_valid()) { - node = base_node.emplace_node(attribute_type, value); - } else { - node.set_reported(value); - node.clear_desired(); - } - - return node; -} - -/** - * @brief Create operation_type_node_type if it doesn't exists, and set the desired value to operation_type (and clear reported) - * - * @see set_user_operation_type - * @see set_credential_operation_type - * @see set_credential_learn_operation_type - * - * @param base_node Base node to search for the attribute - * @param operation_type_node_type Type of the operation type node - * @param operation_type Operation type to set - * - */ -void set_operation_type(attribute_store::attribute base_node, - attribute_store_type_t operation_type_node_type, - user_credential_operation_type_t operation_type) -{ - auto operation_type_node = base_node.emplace_node(operation_type_node_type); - - // Undefine reported to be sure that we can so the same operation twice in a row - operation_type_node.clear_reported(); - operation_type_node.set_desired(operation_type); -} - -/** - * @brief Set User Operation - * - * Set the operation type as desired and clear reported to call SET function - * - * @param user_node User node - * @param operation_type Operation type to set - * - */ -void set_user_operation_type(attribute_store_node_t user_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(user_node, ATTRIBUTE(USER_OPERATION_TYPE), operation_type); -} - -/** - * @brief Set Credential Operation - * - * Set the operation type as desired and clear reported to call SET function - * - * @param slot_node Slot node - * @param operation_type Operation type to set - * - */ -void set_credential_operation_type( - attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - operation_type); -} - -/** - * @brief Set Credential Learn Operation - * - * Set the operation type as desired and clear reported to call SET function - * - * @param slot_node Slot node - * @param operation_type Operation type to set - */ -void set_credential_learn_operation_type( - attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - operation_type); -} - -/** - * @brief Get node associated with user ID (desired or reported) - * - * @param endpoint_node Current endpoint node - * @param user_id User ID - * - * @return True is user exists, false otherwise - */ -bool user_exists(attribute_store::attribute endpoint_node, - user_credential_user_unique_id_t user_id) -{ - return endpoint_node - .child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - user_id, - REPORTED_ATTRIBUTE) - .is_valid(); -} - -/** - * @brief Get node associated with user ID (desired or reported) - * - * @param endpoint_node Current endpoint node - * @param user_id User ID - * @param state Check reported or desired value (or desired else reported) - * - * @throws std::runtime_error If User ID does not exist with given state - * - * @return User ID Node - */ -attribute_store::attribute - get_user_unique_id_node(attribute_store::attribute endpoint_node, - user_credential_user_unique_id_t user_id, - attribute_store_node_value_state_t state) -{ - attribute_store::attribute user_id_node - = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - user_id, - state); - - if (!user_id_node.is_valid()) { - throw std::runtime_error( - (boost::format("User ID %1% not found (state : %2%).") % user_id % state) - .str()); - } - - return user_id_node; -} - -/** - * @brief Get credential type node associated with user ID - * - * @param user_id_node User ID node - * @param cred_type Credential type - * @param state Check reported or desired value (or desired else reported) - * - * @throws std::runtime_error If Credential type for given user_id_node does not exist with given state - * - * @return Credential type node - */ -attribute_store::attribute - get_credential_type_node(attribute_store::attribute user_id_node, - user_credential_type_t cred_type, - attribute_store_node_value_state_t state) -{ - if (!user_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_type_node: User ID node is not valid."); - } - - attribute_store::attribute cred_type_node - = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), - cred_type, - state); - - if (!cred_type_node.is_valid()) { - throw std::runtime_error( - (boost::format("Credential type %1% (state : %2%) not found for %3%.") - % cred_type % state % user_id_node.value_to_string()) - .str()); - } - - return cred_type_node; -} - -/** - * @brief Get credential slot node associated with credential type - * - * @param cred_type_node Credential type node - * @param cred_slot Credential slot - * @param state Check reported or desired value (or desired else reported) - * - * @throws std::runtime_error If Credential slot for given cred_type_node does not exist with given state - * - * @return Credential slot node - */ -attribute_store::attribute - get_credential_slot_node(attribute_store::attribute cred_type_node, - user_credential_slot_t cred_slot, - attribute_store_node_value_state_t state) -{ - if (!cred_type_node.is_valid()) { - throw std::runtime_error( - "get_credential_slot_node: Credential Type node is not valid."); - } - - attribute_store::attribute cred_slot_node - = cred_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), - cred_slot, - state); - - if (!cred_slot_node.is_valid()) { - throw std::runtime_error( - (boost::format( - "Credential slot %1% (state : %2%) not found for %3% / %4%.") - % cred_slot % state % cred_type_node.value_to_string() - % cred_type_node.parent().value_to_string()) - .str()); - } - - return cred_slot_node; -} - -/** - * @brief Iterate on each credential type nodes for a given user - * - * @param user_id_node User ID node - * @param callback Callback function to call for each credential type node - * @param credential_type Credential type to find. If 0, process all credential types - */ -void for_each_credential_type_nodes_for_user( - attribute_store::attribute user_id_node, - const attribute_callback &callback, - user_credential_type_t credential_type = 0) -{ - auto credential_type_nodes - = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); - for (auto &credential_type_node: credential_type_nodes) { - // Call - if (credential_type == 0 - || (credential_type_node.reported_exists() - && credential_type_node.reported() - == credential_type)) { - callback(credential_type_node); - } - } -} - -/** - * @brief Iterate on each credential type nodes - * - * @param endpoint_node Endpoint point node - * @param callback Callback function to call for each credential type node - * @param credential_type Credential type to find. If 0, process all credential types - */ -void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, - const attribute_callback &callback, - user_credential_type_t credential_type = 0) -{ - auto user_nodes = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)); - for (auto &user_node: user_nodes) { - for_each_credential_type_nodes_for_user(user_node, - callback, - credential_type); - } -} - -/** - * @brief Checks if given credential ID (credential type, credential slot) is available - * - * @param endpoint_node Endpoint node - * @param credential_type Credential type - * @param credential_slot Credential slot - * - * @return true Credential is available - * @return false Credential is not available : if an user already have the combination of given credential type and slot. -*/ -bool is_credential_available(attribute_store_node_t endpoint_node, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) -{ - bool credential_available = true; - - for_each_credential_type_nodes(endpoint_node, [&](attribute_store::attribute &credential_type_node) { - for (auto &credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - - // If this credential slot node doesn't have a reported value, check the next one - if (!credential_slot_node.reported_exists()) { - continue; - } - - if (credential_slot_node.reported() - == credential_slot) { - credential_available = false; - return; - } - } - }, credential_type); - - return credential_available; -} - -/** - * @brief Get associated credential identifier nodes - * - * @param child_node Not that have a CREDENTIAL_SLOT, CREDENTIAL_TYPE and USER_UNIQUE_ID as respective parents - * - * @throws std::runtime_error If one of the nodes is not found - * - * @return credential_id_nodes Credential identifier nodes - */ -credential_id_nodes - get_credential_identifier_nodes(attribute_store_node_t child_node) -{ - attribute_store::attribute slot_node(child_node); - slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); - attribute_store::attribute type_node - = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); - attribute_store::attribute user_unique_id_node - = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - if (!slot_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get credential slot node."); - } - - if (!type_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get credential type node."); - } - - if (!user_unique_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get user unique ID node."); - } - return {.slot_node = slot_node, - .type_node = type_node, - .user_unique_id_node = user_unique_id_node}; -} - -template struct identifier_state { - T value; - attribute_store_node_value_state_t state; -}; -/** - * @brief Get associated credential identifier nodes - * - * @param endpoint_node Endpoint node - * @param user_id User ID with given state - * @param credential_type Credential type with given state - * @param credential_slot Credential slot with given state - * - * @throws std::runtime_error If one of the nodes is not found - * - * @return credential_id_nodes Credential identifier nodes - */ -credential_id_nodes get_credential_identifier_nodes( - const attribute_store::attribute &endpoint_node, - identifier_state user_id, - identifier_state credential_type, - identifier_state credential_slot) -{ - credential_id_nodes nodes; - - nodes.user_unique_id_node - = get_user_unique_id_node(endpoint_node, user_id.value, user_id.state); - - if (!nodes.user_unique_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get user unique ID " - + std::to_string(user_id.value)); - } - - nodes.type_node = get_credential_type_node(nodes.user_unique_id_node, - credential_type.value, - credential_type.state); - - if (!nodes.type_node.is_valid()) { - throw std::runtime_error( - (boost::format("get_credential_identifier_nodes: Can't get credential " - "type %1% for user %2%") - % credential_type.value % user_id.value) - .str()); - } - - nodes.slot_node = get_credential_slot_node(nodes.type_node, - credential_slot.value, - credential_slot.state); - - if (!nodes.slot_node.is_valid()) { - throw std::runtime_error( - (boost::format("get_credential_identifier_nodes: Can't get credential " - "slot %1% for credential type %2% / user %3%") - % credential_slot.value % credential_type.value % user_id.value) - .str()); - } - return nodes; -} ///////////////////////////////////////////////////////////////////////////// // Attributes helpers From f2ee9f31cd4ca068ba6b14ce61b687dbb4de39f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 3 Sep 2024 14:29:44 +0200 Subject: [PATCH 40/60] UIC-3222: Move User credential API into their own files Top level API is now available directly with an header to avoid base file to be too big --- .../src/user_credential_cluster_server.cpp | 2 +- .../zwave_command_classes/CMakeLists.txt | 2 + .../user_credential_helpers.cpp | 275 ++ .../user_credential_helpers.hpp | 226 +- .../zwave_command_class_user_credential.cpp | 2240 ++++++----------- .../src/zwave_command_class_user_credential.h | 314 --- ...wave_command_class_user_credential_api.cpp | 803 ++++++ .../zwave_command_class_user_credential_api.h | 353 +++ ...ave_command_class_user_credential_test.cpp | 1 + 9 files changed, 2156 insertions(+), 2060 deletions(-) create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index ec01364fb..95122b37b 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -13,7 +13,7 @@ #include "user_credential_cluster_server.h" #include "zcl_cluster_servers_helpers.hpp" // Interfaces -#include "zwave_command_class_user_credential.h" +#include "zwave_command_class_user_credential_api.h" // ZPC includes #include "zpc_attribute_store.h" diff --git a/applications/zpc/components/zwave_command_classes/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/CMakeLists.txt index c338ae9da..66ea91414 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -57,6 +57,7 @@ add_library( src/zwave_command_class_time.c src/zwave_command_class_user_code.c src/zwave_command_class_user_credential.cpp + src/zwave_command_class_user_credential_api.cpp src/zwave_command_class_version.c src/zwave_command_class_wake_up.c src/zwave_command_class_zwave_plus_info.c @@ -67,6 +68,7 @@ add_library( src/zwave_command_class_protocol.c src/private/user_credential/user_credential_user_capabilities.cpp src/private/user_credential/user_credential_credential_capabilities.cpp + src/private/user_credential/user_credential_checksum_calculator.cpp ) install(TARGETS zwave_command_classes LIBRARY DESTINATION lib) diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp new file mode 100644 index 000000000..907357a19 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp @@ -0,0 +1,275 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ +// Get attribute store names +#include "user_credential_helpers.hpp" + +#include "boost/format.hpp" + +namespace user_credential_helpers +{ + + +void set_operation_type(attribute_store::attribute base_node, + attribute_store_type_t operation_type_node_type, + user_credential_operation_type_t operation_type) +{ + auto operation_type_node = base_node.emplace_node(operation_type_node_type); + + // Undefine reported to be sure that we can so the same operation twice in a row + operation_type_node.clear_reported(); + operation_type_node.set_desired(operation_type); +} + +void set_user_operation_type(attribute_store_node_t user_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type( + user_node, + ATTRIBUTE(USER_OPERATION_TYPE), + operation_type); +} + +void set_credential_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type); +} + +void set_credential_learn_operation_type( + attribute_store_node_t slot_node, + user_credential_operation_type_t operation_type) +{ + set_operation_type(slot_node, + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + operation_type); +} + +bool user_exists(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id) +{ + return endpoint_node + .child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + REPORTED_ATTRIBUTE) + .is_valid(); +} + +attribute_store::attribute + get_user_unique_id_node(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id, + attribute_store_node_value_state_t state) +{ + attribute_store::attribute user_id_node + = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + state); + + if (!user_id_node.is_valid()) { + throw std::runtime_error( + (boost::format("User ID %1% not found (state : %2%).") % user_id % state) + .str()); + } + + return user_id_node; +} + + +attribute_store::attribute + get_credential_type_node(attribute_store::attribute user_id_node, + user_credential_type_t cred_type, + attribute_store_node_value_state_t state) +{ + if (!user_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_type_node: User ID node is not valid."); + } + + attribute_store::attribute cred_type_node + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + cred_type, + state); + + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + (boost::format("Credential type %1% (state : %2%) not found for %3%.") + % cred_type % state % user_id_node.value_to_string()) + .str()); + } + + return cred_type_node; +} + +attribute_store::attribute + get_credential_slot_node(attribute_store::attribute cred_type_node, + user_credential_slot_t cred_slot, + attribute_store_node_value_state_t state) +{ + if (!cred_type_node.is_valid()) { + throw std::runtime_error( + "get_credential_slot_node: Credential Type node is not valid."); + } + + attribute_store::attribute cred_slot_node + = cred_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), + cred_slot, + state); + + if (!cred_slot_node.is_valid()) { + throw std::runtime_error( + (boost::format( + "Credential slot %1% (state : %2%) not found for %3% / %4%.") + % cred_slot % state % cred_type_node.value_to_string() + % cred_type_node.parent().value_to_string()) + .str()); + } + + return cred_slot_node; +} + +void for_each_credential_type_nodes_for_user( + attribute_store::attribute user_id_node, + const attribute_callback &callback, + user_credential_type_t credential_type) +{ + auto credential_type_nodes + = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); + for (auto &credential_type_node: credential_type_nodes) { + // Call + if (credential_type == 0 + || (credential_type_node.reported_exists() + && credential_type_node.reported() + == credential_type)) { + callback(credential_type_node); + } + } +} + +void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, + const attribute_callback &callback, + user_credential_type_t credential_type) +{ + auto user_nodes = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)); + for (auto &user_node: user_nodes) { + for_each_credential_type_nodes_for_user(user_node, + callback, + credential_type); + } +} + + +bool is_credential_available(attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + bool credential_available = true; + + for_each_credential_type_nodes( + endpoint_node, + [&](attribute_store::attribute &credential_type_node) { + for (auto &credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + // If this credential slot node doesn't have a reported value, check the next one + if (!credential_slot_node.reported_exists()) { + continue; + } + + if (credential_slot_node.reported() + == credential_slot) { + credential_available = false; + return; + } + } + }, + credential_type); + + return credential_available; +} + + +credential_id_nodes + get_credential_identifier_nodes(attribute_store_node_t child_node) +{ + attribute_store::attribute slot_node(child_node); + slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); + attribute_store::attribute type_node + = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); + attribute_store::attribute user_unique_id_node + = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + if (!slot_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential slot node."); + } + + if (!type_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get credential type node."); + } + + if (!user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID node."); + } + + return {.slot_node = slot_node, + .type_node = type_node, + .user_unique_id_node = user_unique_id_node}; +} + +credential_id_nodes get_credential_identifier_nodes( + const attribute_store::attribute &endpoint_node, + identifier_state user_id, + identifier_state credential_type, + identifier_state credential_slot) +{ + credential_id_nodes nodes; + + nodes.user_unique_id_node + = get_user_unique_id_node(endpoint_node, user_id.value, user_id.state); + + if (!nodes.user_unique_id_node.is_valid()) { + throw std::runtime_error( + "get_credential_identifier_nodes: Can't get user unique ID " + + std::to_string(user_id.value)); + } + + nodes.type_node = get_credential_type_node(nodes.user_unique_id_node, + credential_type.value, + credential_type.state); + + if (!nodes.type_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "type %1% for user %2%") + % credential_type.value % user_id.value) + .str()); + } + + nodes.slot_node = get_credential_slot_node(nodes.type_node, + credential_slot.value, + credential_slot.state); + + if (!nodes.slot_node.is_valid()) { + throw std::runtime_error( + (boost::format("get_credential_identifier_nodes: Can't get credential " + "slot %1% for credential type %2% / user %3%") + % credential_slot.value % credential_type.value % user_id.value) + .str()); + } + return nodes; +} + +} // namespace user_credential_helpers \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp index 7ae0b07ff..4e138a75e 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp @@ -21,7 +21,7 @@ // Cpp #include "attribute.hpp" -#include "boost/format.hpp" + #include "user_credential_definitions.hpp" @@ -88,15 +88,7 @@ template attribute_store::attribute */ void set_operation_type(attribute_store::attribute base_node, attribute_store_type_t operation_type_node_type, - user_credential_operation_type_t operation_type) -{ - auto operation_type_node = base_node.emplace_node(operation_type_node_type); - - // Undefine reported to be sure that we can so the same operation twice in a row - operation_type_node.clear_reported(); - operation_type_node.set_desired(operation_type); -} - + user_credential_operation_type_t operation_type); /** * @brief Set User Operation * @@ -107,13 +99,7 @@ void set_operation_type(attribute_store::attribute base_node, * */ void set_user_operation_type(attribute_store_node_t user_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type( - user_node, - ATTRIBUTE(USER_OPERATION_TYPE), - operation_type); -} + user_credential_operation_type_t operation_type); /** * @brief Set Credential Operation @@ -126,12 +112,7 @@ void set_user_operation_type(attribute_store_node_t user_node, */ void set_credential_operation_type( attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - operation_type); -} + user_credential_operation_type_t operation_type); /** * @brief Set Credential Learn Operation @@ -143,12 +124,7 @@ void set_credential_operation_type( */ void set_credential_learn_operation_type( attribute_store_node_t slot_node, - user_credential_operation_type_t operation_type) -{ - set_operation_type(slot_node, - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - operation_type); -} + user_credential_operation_type_t operation_type); /** * @brief Get node associated with user ID (desired or reported) @@ -159,14 +135,7 @@ void set_credential_learn_operation_type( * @return True is user exists, false otherwise */ bool user_exists(attribute_store::attribute endpoint_node, - user_credential_user_unique_id_t user_id) -{ - return endpoint_node - .child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - user_id, - REPORTED_ATTRIBUTE) - .is_valid(); -} + user_credential_user_unique_id_t user_id); /** * @brief Get node associated with user ID (desired or reported) @@ -182,21 +151,7 @@ bool user_exists(attribute_store::attribute endpoint_node, attribute_store::attribute get_user_unique_id_node(attribute_store::attribute endpoint_node, user_credential_user_unique_id_t user_id, - attribute_store_node_value_state_t state) -{ - attribute_store::attribute user_id_node - = endpoint_node.child_by_type_and_value(ATTRIBUTE(USER_UNIQUE_ID), - user_id, - state); - - if (!user_id_node.is_valid()) { - throw std::runtime_error( - (boost::format("User ID %1% not found (state : %2%).") % user_id % state) - .str()); - } - - return user_id_node; -} + attribute_store_node_value_state_t state); /** * @brief Get credential type node associated with user ID @@ -212,27 +167,7 @@ attribute_store::attribute attribute_store::attribute get_credential_type_node(attribute_store::attribute user_id_node, user_credential_type_t cred_type, - attribute_store_node_value_state_t state) -{ - if (!user_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_type_node: User ID node is not valid."); - } - - attribute_store::attribute cred_type_node - = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), - cred_type, - state); - - if (!cred_type_node.is_valid()) { - throw std::runtime_error( - (boost::format("Credential type %1% (state : %2%) not found for %3%.") - % cred_type % state % user_id_node.value_to_string()) - .str()); - } - - return cred_type_node; -} + attribute_store_node_value_state_t state); /** * @brief Get credential slot node associated with credential type @@ -248,30 +183,7 @@ attribute_store::attribute attribute_store::attribute get_credential_slot_node(attribute_store::attribute cred_type_node, user_credential_slot_t cred_slot, - attribute_store_node_value_state_t state) -{ - if (!cred_type_node.is_valid()) { - throw std::runtime_error( - "get_credential_slot_node: Credential Type node is not valid."); - } - - attribute_store::attribute cred_slot_node - = cred_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), - cred_slot, - state); - - if (!cred_slot_node.is_valid()) { - throw std::runtime_error( - (boost::format( - "Credential slot %1% (state : %2%) not found for %3% / %4%.") - % cred_slot % state % cred_type_node.value_to_string() - % cred_type_node.parent().value_to_string()) - .str()); - } - - return cred_slot_node; -} - + attribute_store_node_value_state_t state); /** * @brief Iterate on each credential type nodes for a given user * @@ -282,20 +194,7 @@ attribute_store::attribute void for_each_credential_type_nodes_for_user( attribute_store::attribute user_id_node, const attribute_callback &callback, - user_credential_type_t credential_type = 0) -{ - auto credential_type_nodes - = user_id_node.children(ATTRIBUTE(CREDENTIAL_TYPE)); - for (auto &credential_type_node: credential_type_nodes) { - // Call - if (credential_type == 0 - || (credential_type_node.reported_exists() - && credential_type_node.reported() - == credential_type)) { - callback(credential_type_node); - } - } -} + user_credential_type_t credential_type = 0); /** * @brief Iterate on each credential type nodes @@ -306,16 +205,7 @@ void for_each_credential_type_nodes_for_user( */ void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, const attribute_callback &callback, - user_credential_type_t credential_type = 0) -{ - auto user_nodes = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)); - for (auto &user_node: user_nodes) { - for_each_credential_type_nodes_for_user(user_node, - callback, - credential_type); - } -} - + user_credential_type_t credential_type = 0); /** * @brief Checks if given credential ID (credential type, credential slot) is available * @@ -328,31 +218,7 @@ void for_each_credential_type_nodes(attribute_store::attribute endpoint_node, */ bool is_credential_available(attribute_store_node_t endpoint_node, user_credential_type_t credential_type, - user_credential_slot_t credential_slot) -{ - bool credential_available = true; - - for_each_credential_type_nodes( - endpoint_node, - [&](attribute_store::attribute &credential_type_node) { - for (auto &credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - // If this credential slot node doesn't have a reported value, check the next one - if (!credential_slot_node.reported_exists()) { - continue; - } - - if (credential_slot_node.reported() - == credential_slot) { - credential_available = false; - return; - } - } - }, - credential_type); - - return credential_available; -} + user_credential_slot_t credential_slot); /** * @brief Get associated credential identifier nodes @@ -364,34 +230,7 @@ bool is_credential_available(attribute_store_node_t endpoint_node, * @return credential_id_nodes Credential identifier nodes */ credential_id_nodes - get_credential_identifier_nodes(attribute_store_node_t child_node) -{ - attribute_store::attribute slot_node(child_node); - slot_node = slot_node.first_parent_or_self(ATTRIBUTE(CREDENTIAL_SLOT)); - attribute_store::attribute type_node - = slot_node.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)); - attribute_store::attribute user_unique_id_node - = type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - if (!slot_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get credential slot node."); - } - - if (!type_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get credential type node."); - } - - if (!user_unique_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get user unique ID node."); - } - - return {.slot_node = slot_node, - .type_node = type_node, - .user_unique_id_node = user_unique_id_node}; -} + get_credential_identifier_nodes(attribute_store_node_t child_node); template struct identifier_state { T value; @@ -413,44 +252,7 @@ credential_id_nodes get_credential_identifier_nodes( const attribute_store::attribute &endpoint_node, identifier_state user_id, identifier_state credential_type, - identifier_state credential_slot) -{ - credential_id_nodes nodes; - - nodes.user_unique_id_node - = get_user_unique_id_node(endpoint_node, user_id.value, user_id.state); - - if (!nodes.user_unique_id_node.is_valid()) { - throw std::runtime_error( - "get_credential_identifier_nodes: Can't get user unique ID " - + std::to_string(user_id.value)); - } - - nodes.type_node = get_credential_type_node(nodes.user_unique_id_node, - credential_type.value, - credential_type.state); - - if (!nodes.type_node.is_valid()) { - throw std::runtime_error( - (boost::format("get_credential_identifier_nodes: Can't get credential " - "type %1% for user %2%") - % credential_type.value % user_id.value) - .str()); - } - - nodes.slot_node = get_credential_slot_node(nodes.type_node, - credential_slot.value, - credential_slot.state); - - if (!nodes.slot_node.is_valid()) { - throw std::runtime_error( - (boost::format("get_credential_identifier_nodes: Can't get credential " - "slot %1% for credential type %2% / user %3%") - % credential_slot.value % credential_type.value % user_id.value) - .str()); - } - return nodes; -} + identifier_state credential_slot); } // namespace user_credential #endif // USER_CREDENTIAL_HELPERS_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index cf93225d5..e7c3975b0 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -73,64 +73,6 @@ namespace zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); } - - -///////////////////////////////////////////////////////////////////////////// -// Attributes helpers -///////////////////////////////////////////////////////////////////////////// - -/** - * @brief Updates the desired values of attributes in the attribute store. - * - * This function takes a map of attribute values and their corresponding sizes, and updates the desired values - * of the attributes in the attribute store. - * The attribute store is updated for the specified parent node. - * - * @param attribute_map_values A map containing the attribute values and their sizes. - * @param parent_node The parent node of values that will be updated - * - * @return SL_STATUS_OK if the desired values were updated successfully, an otherwise an error code. - */ -sl_status_t update_desired_values( - attribute_store_node_t parent_node, - std::map> - attribute_map_values) -{ - sl_status_t status = SL_STATUS_OK; - for (auto &attr: attribute_map_values) { - auto value = attr.second.first; - auto value_size = attr.second.second; - - if (attribute_store_get_storage_type(attr.first) == C_STRING_STORAGE_TYPE) { - auto str_attribute_node - = attribute_store_get_node_child_by_type(parent_node, attr.first, 0); - auto value_str = static_cast(value); - sl_log_debug(LOG_TAG, - "Update desired value of %s to %s", - attribute_store_get_type_name(attr.first), - value_str); - status - |= attribute_store_set_desired_string(str_attribute_node, value_str); - } else { - sl_log_debug(LOG_TAG, - "Update desired value of %s", - attribute_store_get_type_name(attr.first)); - status |= attribute_store_set_child_desired(parent_node, - attr.first, - value, - value_size); - } - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Error while setting desired value of %s", - attribute_store_get_type_name(attr.first)); - } - } - - return status; -} - ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -1186,7 +1128,6 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( destination_credential_slot, destination_user_id); - // Get destination user node auto destination_user_id_node = get_user_unique_id_node(endpoint_node, @@ -1201,12 +1142,13 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( sl_status_t result = source_credential_slot_node.change_parent( destination_credential_type_node); if (result != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Error while moving slot %d (user %d) to slot %d (user %d)", - source_credential_slot, - source_user_id, - destination_credential_slot, - destination_user_id); + sl_log_error( + LOG_TAG, + "Error while moving slot %d (user %d) to slot %d (user %d)", + source_credential_slot, + source_user_id, + destination_credential_slot, + destination_user_id); return result; } @@ -1222,355 +1164,340 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( return SL_STATUS_OK; } - ///////////////////////////////////////////////////////////////////////////// - // User Set/Get/Report - ///////////////////////////////////////////////////////////////////////////// - - static sl_status_t zwave_command_class_user_credential_user_set( - attribute_store_node_t node, - uint8_t * frame, - uint16_t * frame_length) - { - try { - // Node setup - attribute_store::attribute user_operation_type_node(node); - attribute_store::attribute user_unique_id_node - = user_operation_type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - // Get Values - auto user_unique_id - = user_unique_id_node - .desired_or_reported(); - auto user_operation_type - = user_operation_type_node.desired(); - - const bool is_delete_operation - = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); - - uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; - uint8_t user_name_size = 0; - - if (!is_delete_operation) { - user_name_size = static_cast( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) - .reported() - .size()); - } +///////////////////////////////////////////////////////////////////////////// +// User Set/Get/Report +///////////////////////////////////////////////////////////////////////////// + +static sl_status_t zwave_command_class_user_credential_user_set( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + try { + // Node setup + attribute_store::attribute user_operation_type_node(node); + attribute_store::attribute user_unique_id_node + = user_operation_type_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); + + // Get Values + auto user_unique_id + = user_unique_id_node + .desired_or_reported(); + auto user_operation_type + = user_operation_type_node.desired(); - // Append the user name size (will be 0 if is delete operation) - expected_frame_size += user_name_size; + const bool is_delete_operation + = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); - sl_log_debug(LOG_TAG, - "User SET for user %d (operation type : %d)", - user_unique_id, - user_operation_type); + uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; + uint8_t user_name_size = 0; - // Creating the frame - frame_generator.initialize_frame(USER_SET, frame, expected_frame_size); + if (!is_delete_operation) { + user_name_size = static_cast( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) + .reported() + .size()); + } - frame_generator.add_value(user_operation_type_node, DESIRED_ATTRIBUTE); - frame_generator.add_value(user_unique_id_node, - DESIRED_OR_REPORTED_ATTRIBUTE); + // Append the user name size (will be 0 if is delete operation) + expected_frame_size += user_name_size; - if (!is_delete_operation) { - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_TYPE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_ACTIVE_STATE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_RULE)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value(user_unique_id_node.child_by_type( - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME_ENCODING)), - DESIRED_OR_REPORTED_ATTRIBUTE); - frame_generator.add_raw_byte(user_name_size); - frame_generator.add_value( - user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)), - DESIRED_OR_REPORTED_ATTRIBUTE); - } + sl_log_debug(LOG_TAG, + "User SET for user %d (operation type : %d)", + user_unique_id, + user_operation_type); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating User SET frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + // Creating the frame + frame_generator.initialize_frame(USER_SET, frame, expected_frame_size); + + frame_generator.add_value(user_operation_type_node, DESIRED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + + if (!is_delete_operation) { + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_TYPE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_ACTIVE_STATE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_RULE)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value(user_unique_id_node.child_by_type( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME_ENCODING)), + DESIRED_OR_REPORTED_ATTRIBUTE); + frame_generator.add_raw_byte(user_name_size); + frame_generator.add_value( + user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)), + DESIRED_OR_REPORTED_ATTRIBUTE); } - return SL_STATUS_OK; - } - static sl_status_t zwave_command_class_user_credential_user_get( - attribute_store_node_t node, - uint8_t * frame, - uint16_t * frame_length) - { - attribute_store::attribute user_unique_id_node(node); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User SET frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + return SL_STATUS_OK; +} - // If we enter this state it means that something went badly wrong or - // user initiate the interview process again. - // In both cases we want to invalidate the user database so that the device - // can send us the correct user database. +static sl_status_t zwave_command_class_user_credential_user_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + attribute_store::attribute user_unique_id_node(node); - if (!user_unique_id_node.desired_exists()) { - sl_log_warning( - LOG_TAG, - "Can't get user unique id Desired value. Removing all users " - "to perform interview again."); - attribute_store::attribute endpoint_node = user_unique_id_node.parent(); + // If we enter this state it means that something went badly wrong or + // user initiate the interview process again. + // In both cases we want to invalidate the user database so that the device + // can send us the correct user database. - // Get User node count - for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { - attribute_store_delete_node(user_node); - } + if (!user_unique_id_node.desired_exists()) { + sl_log_warning(LOG_TAG, + "Can't get user unique id Desired value. Removing all users " + "to perform interview again."); + attribute_store::attribute endpoint_node = user_unique_id_node.parent(); - // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. - return SL_STATUS_NOT_SUPPORTED; + // Get User node count + for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + attribute_store_delete_node(user_node); } - user_credential_user_unique_id_t user_id - = user_unique_id_node.desired(); - sl_log_debug(LOG_TAG, "User Get for user %d", user_id); + // NOTE : In the case of user re-interviewing the device, it will be interviewed again when the node goes ONLINE. + return SL_STATUS_NOT_SUPPORTED; + } - // Generate the frame - constexpr uint8_t expected_frame_size - = static_cast(sizeof(ZW_USER_GET_FRAME)); - try { - frame_generator.initialize_frame(USER_GET, frame, expected_frame_size); - frame_generator.add_value(user_unique_id_node, DESIRED_ATTRIBUTE); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating USER_GET frame : %s", - e.what()); - return SL_STATUS_FAIL; - } + user_credential_user_unique_id_t user_id + = user_unique_id_node.desired(); + sl_log_debug(LOG_TAG, "User Get for user %d", user_id); - // This special user ID will contains the unaffected credentials. - if (user_id == 0) { - sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); - user_unique_id_node.clear_desired(); - user_unique_id_node.set_reported(user_id); - } + // Generate the frame + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_GET_FRAME)); + try { + frame_generator.initialize_frame(USER_GET, frame, expected_frame_size); + frame_generator.add_value(user_unique_id_node, DESIRED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating USER_GET frame : %s", + e.what()); + return SL_STATUS_FAIL; + } - return SL_STATUS_OK; + // This special user ID will contains the unaffected credentials. + if (user_id == 0) { + sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); + user_unique_id_node.clear_desired(); + user_unique_id_node.set_reported(user_id); } - // TODO : Update with values in ZW_cmdclass.h - enum class user_report_type_t : uint8_t { - USER_ADDED = 0x00, - USER_MODIFIED = 0x01, - USER_DELETED = 0x02, - USER_UNCHANGED = 0x03, - RESPONSE_TO_GET = 0x04, - USER_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, - USER_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, - NON_ZERO_EXPIRING_MINUTES_INVALID = 0x07 - }; + return SL_STATUS_OK; +} - sl_status_t zwave_command_class_user_credential_user_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) - { - sl_log_debug(LOG_TAG, "User Report"); +// TODO : Update with values in ZW_cmdclass.h +enum class user_report_type_t : uint8_t { + USER_ADDED = 0x00, + USER_MODIFIED = 0x01, + USER_DELETED = 0x02, + USER_UNCHANGED = 0x03, + RESPONSE_TO_GET = 0x04, + USER_ADD_REJECTED_LOCATION_OCCUPIED = 0x05, + USER_MODIFY_REJECTED_LOCATION_EMPTY = 0x06, + NON_ZERO_EXPIRING_MINUTES_INVALID = 0x07 +}; + +sl_status_t zwave_command_class_user_credential_user_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + sl_log_debug(LOG_TAG, "User Report"); - attribute_store::attribute endpoint_node( - zwave_command_class_get_endpoint_node(connection_info)); + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); - const uint8_t expected_min_size = 16; + const uint8_t expected_min_size = 16; - try { - zwave_frame_parser parser(frame_data, frame_length); + try { + zwave_frame_parser parser(frame_data, frame_length); - if (!parser.is_frame_size_valid(expected_min_size, UINT8_MAX)) { - sl_log_error(LOG_TAG, "Invalid frame size for User Report frame"); - return SL_STATUS_FAIL; - } + if (!parser.is_frame_size_valid(expected_min_size, UINT8_MAX)) { + sl_log_error(LOG_TAG, "Invalid frame size for User Report frame"); + return SL_STATUS_FAIL; + } - auto user_report_type - = static_cast(parser.read_byte()); + auto user_report_type = static_cast(parser.read_byte()); - auto next_user_id - = parser.read_sequential(2); + auto next_user_id + = parser.read_sequential(2); - user_credential_modifier_type_t user_modifier_type = parser.read_byte(); - auto user_modifier_id - = parser.read_sequential(2); + user_credential_modifier_type_t user_modifier_type = parser.read_byte(); + auto user_modifier_id + = parser.read_sequential(2); - // Get User ID - auto current_user_id - = parser.read_sequential(2); + // Get User ID + auto current_user_id + = parser.read_sequential(2); - sl_log_debug(LOG_TAG, - "User report for user %d. User report type %d", - current_user_id, - user_report_type); - - // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node - if (current_user_id == 0) { - if (user_report_type == user_report_type_t::RESPONSE_TO_GET) { - sl_log_info(LOG_TAG, "No users was found on the device."); - return SL_STATUS_OK; - } else if (user_report_type == user_report_type_t::USER_DELETED) { - sl_log_info(LOG_TAG, "Request to delete all users"); - - for (auto user_node: - endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { - // Don't delete special user 0 - if (user_node.reported_exists() - && user_node.reported() - == 0) { - continue; - } - - attribute_store_delete_node(user_node); + sl_log_debug(LOG_TAG, + "User report for user %d. User report type %d", + current_user_id, + user_report_type); + + // CC:0083.01.05.11.006: Zero is an invalid User Unique Identifier and MUST NOT be used by the node + if (current_user_id == 0) { + if (user_report_type == user_report_type_t::RESPONSE_TO_GET) { + sl_log_info(LOG_TAG, "No users was found on the device."); + return SL_STATUS_OK; + } else if (user_report_type == user_report_type_t::USER_DELETED) { + sl_log_info(LOG_TAG, "Request to delete all users"); + + for (auto user_node: + endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + // Don't delete special user 0 + if (user_node.reported_exists() + && user_node.reported() == 0) { + continue; } - return SL_STATUS_OK; - } else { - sl_log_error( - LOG_TAG, - "User report with ID 0 received. This is an invalid User " - "Unique Identifier and MUST NOT be used by the node."); - return SL_STATUS_FAIL; + attribute_store_delete_node(user_node); } - } - // Lambda function to remove user node in an invalid state - auto remove_current_user_node = [&]() { - get_user_unique_id_node(endpoint_node, - current_user_id, - DESIRED_ATTRIBUTE) - .delete_node(); - }; - - // Current user id node that will be used later - // Each report type has a different behavior - attribute_store::attribute current_user_id_node; - switch (user_report_type) { - // Need to create new user node - case user_report_type_t::USER_ADDED: - current_user_id_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - // If this is the first user we get it might not exists yet so we create it. - // Otherwise we just update the reported value - case user_report_type_t::RESPONSE_TO_GET: - current_user_id_node - = create_or_update_desired_value(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - break; - // We should have a record of given user ID - case user_report_type_t::USER_MODIFIED: - case user_report_type_t::USER_DELETED: - current_user_id_node = get_user_unique_id_node(endpoint_node, - current_user_id, - REPORTED_ATTRIBUTE); - break; - // Special/Errors cases - case user_report_type_t::USER_UNCHANGED: - sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); - return SL_STATUS_OK; - case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: - sl_log_warning( - LOG_TAG, - "User %d was not added since it already exists. Try to " - "modify it instead.", - current_user_id); - remove_current_user_node(); - return SL_STATUS_OK; - case user_report_type_t::USER_MODIFY_REJECTED_LOCATION_EMPTY: - sl_log_warning( - LOG_TAG, - "User %d was not modified since it doesn't exists. Try " - "to add it instead.", - current_user_id); - remove_current_user_node(); - return SL_STATUS_OK; - case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: - sl_log_warning(LOG_TAG, - "User %d was not modified/added since the expiring " - "timeout minutes is invalid.", - current_user_id); - return SL_STATUS_OK; - default: - sl_log_error(LOG_TAG, "Invalid value for user report type."); - return SL_STATUS_FAIL; - }; - - // Deleted special case - if (user_report_type == user_report_type_t::USER_DELETED) { - // TODO : move all credential from this user to user 0 - // Maybe it is done automatically by the credential report - sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); - current_user_id_node.delete_node(); return SL_STATUS_OK; + } else { + sl_log_error(LOG_TAG, + "User report with ID 0 received. This is an invalid User " + "Unique Identifier and MUST NOT be used by the node."); + return SL_STATUS_FAIL; } + } - // Set already parsed values - current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) - .set_reported(user_modifier_type); - current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_NODE_ID)) - .set_reported(user_modifier_id); + // Lambda function to remove user node in an invalid state + auto remove_current_user_node = [&]() { + get_user_unique_id_node(endpoint_node, current_user_id, DESIRED_ATTRIBUTE) + .delete_node(); + }; - // Keep parsing the frame - parser.read_byte(current_user_id_node.emplace_node(ATTRIBUTE(USER_TYPE))); - parser.read_byte_with_bitmask( - {USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK, - current_user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE))}); - parser.read_byte( - current_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE))); - parser.read_sequential( - 2, - current_user_id_node.emplace_node( - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES))); - parser.read_byte_with_bitmask( - {USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK, - current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING))}); - parser.read_string( - current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME))); + // Current user id node that will be used later + // Each report type has a different behavior + attribute_store::attribute current_user_id_node; + switch (user_report_type) { + // Need to create new user node + case user_report_type_t::USER_ADDED: + current_user_id_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + // If this is the first user we get it might not exists yet so we create it. + // Otherwise we just update the reported value + case user_report_type_t::RESPONSE_TO_GET: + current_user_id_node + = create_or_update_desired_value(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + current_user_id); + break; + // We should have a record of given user ID + case user_report_type_t::USER_MODIFIED: + case user_report_type_t::USER_DELETED: + current_user_id_node = get_user_unique_id_node(endpoint_node, + current_user_id, + REPORTED_ATTRIBUTE); + break; + // Special/Errors cases + case user_report_type_t::USER_UNCHANGED: + sl_log_info(LOG_TAG, "User %d is unchanged", current_user_id); + return SL_STATUS_OK; + case user_report_type_t::USER_ADD_REJECTED_LOCATION_OCCUPIED: + sl_log_warning(LOG_TAG, + "User %d was not added since it already exists. Try to " + "modify it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::USER_MODIFY_REJECTED_LOCATION_EMPTY: + sl_log_warning(LOG_TAG, + "User %d was not modified since it doesn't exists. Try " + "to add it instead.", + current_user_id); + remove_current_user_node(); + return SL_STATUS_OK; + case user_report_type_t::NON_ZERO_EXPIRING_MINUTES_INVALID: + sl_log_warning(LOG_TAG, + "User %d was not modified/added since the expiring " + "timeout minutes is invalid.", + current_user_id); + return SL_STATUS_OK; + default: + sl_log_error(LOG_TAG, "Invalid value for user report type."); + return SL_STATUS_FAIL; + }; - // Get credentials - trigger_get_credential(current_user_id_node, 0, 0); + // Deleted special case + if (user_report_type == user_report_type_t::USER_DELETED) { + // TODO : move all credential from this user to user 0 + // Maybe it is done automatically by the credential report + sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); + current_user_id_node.delete_node(); + return SL_STATUS_OK; + } - if (next_user_id != 0 - && user_report_type == user_report_type_t::RESPONSE_TO_GET) { - if (!user_exists(endpoint_node, next_user_id)) { - sl_log_debug(LOG_TAG, - "Trigger a get for next user (%d)", - next_user_id); - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(next_user_id); - } else { - sl_log_error(LOG_TAG, - "User %d already exists. Not discovering more users.", - next_user_id); - } + // Set already parsed values + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_TYPE)) + .set_reported(user_modifier_type); + current_user_id_node.emplace_node(ATTRIBUTE(USER_MODIFIER_NODE_ID)) + .set_reported(user_modifier_id); + + // Keep parsing the frame + parser.read_byte(current_user_id_node.emplace_node(ATTRIBUTE(USER_TYPE))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES1_USER_ACTIVE_STATE_BIT_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE))}); + parser.read_byte( + current_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE))); + parser.read_sequential( + 2, + current_user_id_node.emplace_node( + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES))); + parser.read_byte_with_bitmask( + {USER_REPORT_PROPERTIES2_USER_NAME_ENCODING_MASK, + current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING))}); + parser.read_string(current_user_id_node.emplace_node(ATTRIBUTE(USER_NAME))); + + // Get credentials + trigger_get_credential(current_user_id_node, 0, 0); + + if (next_user_id != 0 + && user_report_type == user_report_type_t::RESPONSE_TO_GET) { + if (!user_exists(endpoint_node, next_user_id)) { + sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(next_user_id); } else { - sl_log_debug(LOG_TAG, "No more users to discover"); + sl_log_error(LOG_TAG, + "User %d already exists. Not discovering more users.", + next_user_id); } - - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while parsing User Report frame : %s", - e.what()); - return SL_STATUS_FAIL; + } else { + sl_log_debug(LOG_TAG, "No more users to discover"); } - return SL_STATUS_OK; + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Report frame : %s", + e.what()); + return SL_STATUS_FAIL; } - ///////////////////////////////////////////////////////////////////////////// - // Checksum helpers - ///////////////////////////////////////////////////////////////////////////// + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Checksum helpers +///////////////////////////////////////////////////////////////////////////// - /** +/** * @brief Compte the checksum and verify the checksum integrity. * * Compare crc16 of checksum_data and expected checksum and put it in the @@ -1583,1246 +1510,493 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( * * @return SL_STATUS_OK if checksum is correct, SL_STATUS_FAIL otherwise */ - sl_status_t check_checksum_value(attribute_store::attribute base_node, - attribute_store_type_t checksum_error_type, - user_credential_checksum_t computed_checksum, - user_credential_checksum_t expected_checksum) - { - sl_status_t status = SL_STATUS_FAIL; - - if (computed_checksum != expected_checksum) { - sl_log_error(LOG_TAG, - "Checksum mismatch (%s). Expected 0x%X, got 0x%X", - base_node.value_to_string().c_str(), - expected_checksum, - computed_checksum); - base_node.emplace_node(checksum_error_type) - .set_reported(computed_checksum); - } else { - // If we don't have any errors we remove the checksum_error_type node - base_node.child_by_type(checksum_error_type).delete_node(); - status = SL_STATUS_OK; - } +sl_status_t check_checksum_value(attribute_store::attribute base_node, + attribute_store_type_t checksum_error_type, + user_credential_checksum_t computed_checksum, + user_credential_checksum_t expected_checksum) +{ + sl_status_t status = SL_STATUS_FAIL; - return status; + if (computed_checksum != expected_checksum) { + sl_log_error(LOG_TAG, + "Checksum mismatch (%s). Expected 0x%X, got 0x%X", + base_node.value_to_string().c_str(), + expected_checksum, + computed_checksum); + base_node.emplace_node(checksum_error_type).set_reported(computed_checksum); + } else { + // If we don't have any errors we remove the checksum_error_type node + base_node.child_by_type(checksum_error_type).delete_node(); + status = SL_STATUS_OK; } - ///////////////////////////////////////////////////////////////////////////// - // User Checksum Get/Report - ///////////////////////////////////////////////////////////////////////////// - static sl_status_t zwave_command_class_user_credential_user_checksum_get( - attribute_store_node_t node, - uint8_t * frame, - uint16_t * frame_length) - { - sl_log_debug(LOG_TAG, "User Checksum Get"); - attribute_store::attribute checksum_node(node); - - auto user_id_node = checksum_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - - if (!user_id_node.is_valid()) { - sl_log_error( - LOG_TAG, - "Can't find User Unique ID node. Not sending User Checksum Get."); - return SL_STATUS_NOT_SUPPORTED; - } + return status; +} - constexpr uint8_t expected_frame_size - = static_cast(sizeof(ZW_USER_CHECKSUM_GET_FRAME)); +///////////////////////////////////////////////////////////////////////////// +// User Checksum Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t zwave_command_class_user_credential_user_checksum_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "User Checksum Get"); + attribute_store::attribute checksum_node(node); - try { - frame_generator.initialize_frame(USER_CHECKSUM_GET, - frame, - expected_frame_size); - frame_generator.add_value(user_id_node); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating User Checksum Get frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; - } + auto user_id_node = checksum_node.first_parent(ATTRIBUTE(USER_UNIQUE_ID)); - return SL_STATUS_OK; + if (!user_id_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Can't find User Unique ID node. Not sending User Checksum Get."); + return SL_STATUS_NOT_SUPPORTED; } - sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) - { - sl_status_t result = SL_STATUS_FAIL; - - constexpr uint8_t expected_frame_length - = sizeof(ZW_USER_CHECKSUM_REPORT_FRAME); + constexpr uint8_t expected_frame_size + = static_cast(sizeof(ZW_USER_CHECKSUM_GET_FRAME)); - attribute_store::attribute endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); - - try { - zwave_frame_parser parser(frame_data, frame_length); + try { + frame_generator.initialize_frame(USER_CHECKSUM_GET, + frame, + expected_frame_size); + frame_generator.add_value(user_id_node); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating User Checksum Get frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } - if (!parser.is_frame_size_valid(expected_frame_length)) { - sl_log_error(LOG_TAG, - "Invalid frame size for User Checksum Report frame"); - return SL_STATUS_NOT_SUPPORTED; - } + return SL_STATUS_OK; +} - // Parse the frame - const auto user_id - = parser.read_sequential(2); - const auto user_checksum - = parser.read_sequential(2); +sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + sl_status_t result = SL_STATUS_FAIL; - sl_log_debug(LOG_TAG, - "User Checksum Report. Source User ID: %d / " - "Checksum: 0x%X", - user_id, - user_checksum); - - auto user_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - - user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) - .set_reported(user_checksum); - - // Compute checksum ourselves to see if it matches - user_credential::checksum_calculator checksum_calculator; - - // First gather all the User values - const std::vector user_attributes = { - ATTRIBUTE(USER_TYPE), - ATTRIBUTE(USER_ACTIVE_STATE), - ATTRIBUTE(CREDENTIAL_RULE), - ATTRIBUTE(USER_NAME_ENCODING), - ATTRIBUTE(USER_NAME), - }; - for (auto attribute: user_attributes) { - checksum_calculator.add_node(user_node.child_by_type(attribute)); - } + constexpr uint8_t expected_frame_length + = sizeof(ZW_USER_CHECKSUM_REPORT_FRAME); - // The all credential data - for (auto credential_type_node: - user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { - sl_log_debug( - LOG_TAG, - "%d reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); - continue; - } + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); - // Add credential type to checksum - checksum_calculator.add_node(credential_type_node); - // Add credential slot to checksum - checksum_calculator.add_node(credential_slot_node); - checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); - } - } + try { + zwave_frame_parser parser(frame_data, frame_length); - result = check_checksum_value(user_node, - ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), - checksum_calculator.compute_checksum(), - user_checksum); - } catch (const std::exception &e) { + if (!parser.is_frame_size_valid(expected_frame_length)) { sl_log_error(LOG_TAG, - "Error while parsing User Checksum Report frame : %s", - e.what()); + "Invalid frame size for User Checksum Report frame"); return SL_STATUS_NOT_SUPPORTED; } - return result; - } + // Parse the frame + const auto user_id + = parser.read_sequential(2); + const auto user_checksum + = parser.read_sequential(2); - ///////////////////////////////////////////////////////////////////////////// - // Credential Checksum Get/Report - ///////////////////////////////////////////////////////////////////////////// + sl_log_debug(LOG_TAG, + "User Checksum Report. Source User ID: %d / " + "Checksum: 0x%X", + user_id, + user_checksum); - static sl_status_t - zwave_command_class_user_credential_credential_checksum_get( - attribute_store_node_t node, - uint8_t * frame, - uint16_t * frame_length) - { - sl_log_debug(LOG_TAG, "Credential Checksum Get"); + auto user_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - attribute_store::attribute credential_checksum_node(node); - try { - auto credential_type_node = credential_checksum_node.first_parent( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); + user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) + .set_reported(user_checksum); - if (!credential_type_node.is_valid()) { - sl_log_error(LOG_TAG, - "Can't find Credential Type node. Not sending Credential " - "Checksum Get."); - return SL_STATUS_NOT_SUPPORTED; - } + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; - frame_generator.initialize_frame( - CREDENTIAL_CHECKSUM_GET, - frame, - sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME)); + // First gather all the User values + const std::vector user_attributes = { + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME), + }; + for (auto attribute: user_attributes) { + checksum_calculator.add_node(user_node.child_by_type(attribute)); + } - frame_generator.add_value(credential_type_node, REPORTED_ATTRIBUTE); - frame_generator.validate_frame(frame_length); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while generating Credential Checksum Get frame : %s", - e.what()); - return SL_STATUS_NOT_SUPPORTED; + // The all credential data + for (auto credential_type_node: + user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%d reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } + + // Add credential type to checksum + checksum_calculator.add_node(credential_type_node); + // Add credential slot to checksum + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); + } } - return SL_STATUS_OK; + result = check_checksum_value(user_node, + ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + user_checksum); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - sl_status_t - zwave_command_class_user_credential_credential_checksum_handle_report( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) - { - sl_status_t result = SL_STATUS_FAIL; + return result; +} - attribute_store::attribute endpoint_node - = zwave_command_class_get_endpoint_node(connection_info); +///////////////////////////////////////////////////////////////////////////// +// Credential Checksum Get/Report +///////////////////////////////////////////////////////////////////////////// - constexpr uint8_t expected_frame_length - = sizeof(ZW_CREDENTIAL_CHECKSUM_REPORT_FRAME); - try { - zwave_frame_parser parser(frame_data, frame_length); +static sl_status_t zwave_command_class_user_credential_credential_checksum_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Checksum Get"); - if (!parser.is_frame_size_valid(expected_frame_length)) { - sl_log_error(LOG_TAG, - "Invalid frame size for Credential Checksum Report frame"); - return SL_STATUS_NOT_SUPPORTED; - } - - // Parse the frame - const user_credential_type_t credential_type = parser.read_byte(); - const auto credential_checksum - = parser.read_sequential(2); - - sl_log_debug(LOG_TAG, - "Credential Checksum Report. Credential type: %d / " - "Checksum: 0x%X", - credential_type, - credential_checksum); - - // Get the credential type node - auto credential_type_node = endpoint_node.child_by_type_and_value( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - credential_type); - if (!credential_type_node.is_valid()) { - sl_log_error(LOG_TAG, - "Can't find Credential Type %d reported by Credential " - "Checksum Report", - credential_type); - return SL_STATUS_FAIL; - } - - credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)) - .set_reported(credential_checksum); + attribute_store::attribute credential_checksum_node(node); + try { + auto credential_type_node = credential_checksum_node.first_parent( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE)); - // Compute checksum ourselves to see if it matches - user_credential::checksum_calculator checksum_calculator; - for_each_credential_type_nodes( - endpoint_node, - [&](auto credential_type_node) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { - sl_log_debug( - LOG_TAG, - "%s reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); - continue; - } - - checksum_calculator.add_node(credential_slot_node); - checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); - } - }, - credential_type); - - result - = check_checksum_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), - checksum_calculator.compute_checksum(), - credential_checksum); - } catch (const std::exception &e) { + if (!credential_type_node.is_valid()) { sl_log_error(LOG_TAG, - "Error while parsing Credential Checksum Report frame : %s", - e.what()); + "Can't find Credential Type node. Not sending Credential " + "Checksum Get."); return SL_STATUS_NOT_SUPPORTED; } - return result; - } - - ///////////////////////////////////////////////////////////////////////////// - // Post interview actions - ///////////////////////////////////////////////////////////////////////////// - void zwave_network_status_changed(attribute_store_node_t node, - attribute_store_change_t change) - { - // We englobe this in case we can't read an attribute or something goes wrong - try { - attribute_store::attribute network_status_node(node); - auto node_id_node = network_status_node.first_parent(ATTRIBUTE_NODE_ID); - - // Should not happen but we check anyway to prevent an exception to raise - if (!node_id_node.reported_exists()) { - return; - } - - auto node_id = node_id_node.reported(); - - // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything - if (change == ATTRIBUTE_DELETED - || get_zpc_node_id_node() == node_id_node) { - return; - } - - // If the endpoint report is marked as ONLINE_FUNCTIONAL - if (network_status_node.reported() - == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { - sl_log_debug(LOG_TAG, - "Node %d is now ONLINE_FUNCTIONAL : start the delayed " - "interview process", - node_id); - // Perform action on each endpoint that supports User Credential Command class - sl_log_debug(LOG_TAG, "Checking endpoints..."); - for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { - auto endpoint_id = endpoint_node.reported(); - // Check if the endpoint supports User Credential Command class - if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, - node_id, - endpoint_id)) { - sl_log_debug(LOG_TAG, - "Endpoint %d supports User Credential.", - endpoint_id); - auto user_count - = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); - if (user_count == 0) { - sl_log_debug( - LOG_TAG, - "No user found. Starting User and Credential interview"); - // Start the interview process with user ID = 0 - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(0); - } else { - sl_log_debug(LOG_TAG, - "Users already discovered. No actions needed."); - } - } - } - sl_log_debug(LOG_TAG, "Done."); - } - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while handling network status change : %s", - e.what()); - } - } - - ///////////////////////////////////////////////////////////////////////////// - // Exposed class functions - ///////////////////////////////////////////////////////////////////////////// - - sl_status_t zwave_command_class_user_credential_add_new_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name) - { - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); - return SL_STATUS_FAIL; - } - - // Node already exists, can't create user. - if (user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d already exists. Not adding user.", - user_id); - return SL_STATUS_FAIL; - } - - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_add_new_user called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); - sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); - sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); - sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); - sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); - sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, - "User capabilities are not valid. Not adding user."); - return SL_STATUS_FAIL; - } - - // Create the user node - auto user_id_node = attribute_store_emplace_desired(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_TYPE), - &user_type, - sizeof(user_type)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_RULE), - &credential_rule, - sizeof(credential_rule)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_ACTIVE_STATE), - &user_active_state, - sizeof(user_active_state)); - - if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - if (expiring_timeout != 0) { - sl_log_warning( - LOG_TAG, - "Expiring timeout set for non-expiring user, set value to 0."); - } - expiring_timeout = 0; - } - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - &expiring_timeout, - sizeof(expiring_timeout)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_NAME_ENCODING), - &user_name_encoding, - sizeof(user_name_encoding)); - // User name node - auto user_name_node - = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); - attribute_store_set_desired_string(user_name_node, user_name); - - // Finally set operation type add - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); - - sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); - - return SL_STATUS_OK; - } - - sl_status_t zwave_command_class_user_credential_delete_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) - { - if (!user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d doesn't exists. Not deleting user.", - user_id); - return SL_STATUS_FAIL; - } - - attribute_store_node_t user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - - // Finally set operation type delete - set_user_operation_type(user_id_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); - - sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); - - return SL_STATUS_OK; - } - - sl_status_t zwave_command_class_user_credential_modify_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name) - { - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); - return SL_STATUS_FAIL; - } - - if (!user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d doesn't exists. Can't modify user.", - user_id); - return SL_STATUS_FAIL; - } - - // Check if the user already exists - attribute_store_node_t user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_modify_user called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); - sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); - sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); - sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); - sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); - sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, - "User capabilities are not valid. Not adding user."); - return SL_STATUS_FAIL; - } - - std::map> values - = { - {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, - {ATTRIBUTE(CREDENTIAL_RULE), - {&credential_rule, sizeof(credential_rule)}}, - {ATTRIBUTE(USER_ACTIVE_STATE), - {&user_active_state, sizeof(user_active_state)}}, - {ATTRIBUTE(USER_NAME_ENCODING), - {&user_name_encoding, sizeof(user_name_encoding)}}, - {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, - }; - - // Only add expiring timeout if user is expiring - if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - {&expiring_timeout, sizeof(expiring_timeout)}}); - } - - // Update values based on the map - sl_status_t status = update_desired_values(user_id_node, values); - // If everything went well set operation type to modify - if (status == SL_STATUS_OK) { - set_user_operation_type(user_id_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); - } else { - sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); - } - - return status; - } - - sl_status_t zwave_command_class_user_credential_add_new_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char *credential_data) - { - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_add_new_credential called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - - // Check if parameters are ok - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; - } - - auto capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); - - if (!capabilities.is_slot_valid(credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d is not valid. " - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } - - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists." - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } - - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - // Get or create credential type node - auto credential_type_node - = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), - credential_type); - - // Process credential data - std::vector credential_data_vector - = capabilities.convert_and_validate_credential_data(credential_data, - credential_slot); - - auto credential_slot_node - = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot, - DESIRED_ATTRIBUTE); - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), - credential_data_vector, - DESIRED_ATTRIBUTE); - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while trying to add a new credential : %s", - e.what()); - return SL_STATUS_FAIL; - } + frame_generator.initialize_frame(CREDENTIAL_CHECKSUM_GET, + frame, + sizeof(ZW_CREDENTIAL_CHECKSUM_GET_FRAME)); - return SL_STATUS_OK; + frame_generator.add_value(credential_type_node, REPORTED_ATTRIBUTE); + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating Credential Checksum Get frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - sl_status_t zwave_command_class_user_credential_modify_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char *credential_data) - { - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_modify_credential called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - - // Check if parameters are ok - if (user_id == 0 || credential_type == 0 || credential_slot == 0) { - sl_log_error(LOG_TAG, - "User ID, Credential Type and Slot 0 are reserved. Not " - "modifying credentials."); - return SL_STATUS_FAIL; - } - - try { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); - // Get current credential slot node - auto credential_slot_node = nodes.slot_node; - // Process credential data - auto capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); - std::vector credential_data_vector - = capabilities.convert_and_validate_credential_data(credential_data, - credential_slot); - // Modify current data - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) - .set_desired(credential_data_vector); - - // Finally set operation type modify - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while trying to modify a credential : %s", - e.what()); - return SL_STATUS_FAIL; - } + return SL_STATUS_OK; +} - return SL_STATUS_OK; - } +sl_status_t + zwave_command_class_user_credential_credential_checksum_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + sl_status_t result = SL_STATUS_FAIL; - sl_status_t zwave_command_class_user_credential_delete_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) - { - sl_log_debug(LOG_TAG, - "Delete credential slot %d (credential type %d, user id %d)", - credential_slot, - credential_type, - user_id); + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); - try { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); + constexpr uint8_t expected_frame_length + = sizeof(ZW_CREDENTIAL_CHECKSUM_REPORT_FRAME); + try { + zwave_frame_parser parser(frame_data, frame_length); - // Finally set operation type delete - set_credential_operation_type(nodes.slot_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); - } catch (const std::exception &e) { + if (!parser.is_frame_size_valid(expected_frame_length)) { sl_log_error(LOG_TAG, - "Error while trying to delete a credential : %s", - e.what()); - return SL_STATUS_FAIL; + "Invalid frame size for Credential Checksum Report frame"); + return SL_STATUS_NOT_SUPPORTED; } - return SL_STATUS_OK; - } - - sl_status_t zwave_command_class_user_credential_delete_all_users( - attribute_store_node_t endpoint_node) - { - attribute_store::attribute cpp_endpoint_node(endpoint_node); - user_credential_user_unique_id_t user_id = 0; - auto user_id_node - = cpp_endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); - - // Finally set operation type delete - set_user_operation_type(user_id_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); - - sl_log_debug(LOG_TAG, - "Delete all user operation received. Creating user with id %d " - "to send a User SET.", - user_id); - return SL_STATUS_OK; - } - - void trigger_credential_deletion(attribute_store::attribute endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot) - { - auto credential_slot_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id) - .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type) - .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), credential_slot); - - // Finally set operation type delete - set_credential_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_DELETE); + // Parse the frame + const user_credential_type_t credential_type = parser.read_byte(); + const auto credential_checksum + = parser.read_sequential(2); sl_log_debug(LOG_TAG, - "Creating user with id %d, credential type %d and slot " - "both to %d to send a Credential SET.", - user_id, + "Credential Checksum Report. Credential type: %d / " + "Checksum: 0x%X", credential_type, - credential_slot); - } + credential_checksum); - sl_status_t zwave_command_class_user_credential_delete_all_credentials( - attribute_store_node_t endpoint_node) - { - sl_log_debug(LOG_TAG, "Delete all credential operation received"); - - trigger_credential_deletion(endpoint_node, 0, 0, 0); - - return SL_STATUS_OK; - } - - sl_status_t - zwave_command_class_user_credential_delete_all_credentials_by_type( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type) - { - sl_log_debug(LOG_TAG, - "Delete all credential of type %d operation received", - credential_type); - - trigger_credential_deletion(endpoint_node, 0, credential_type, 0); - - return SL_STATUS_OK; - } - - sl_status_t - zwave_command_class_user_credential_delete_all_credentials_for_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) - { - sl_log_debug(LOG_TAG, - "Delete all credential for user %d operation received", - user_id); - - trigger_credential_deletion(endpoint_node, user_id, 0, 0); - - return SL_STATUS_OK; - } - - sl_status_t - zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type) - { - sl_log_debug(LOG_TAG, - "Delete all credential for user %d and credential type %d " - "operation received", - user_id, - credential_type); - - trigger_credential_deletion(endpoint_node, user_id, credential_type, 0); - - return SL_STATUS_OK; - } - - sl_status_t zwave_command_class_user_credential_credential_learn_start_add( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout) - { - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (Add)" - " called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); - - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); - - if (!credential_capabilities.is_learn_supported()) { - sl_log_error( - LOG_TAG, - "Learn is not supported for credential type %d. Not starting " - "learn process.", - credential_type); - return SL_STATUS_FAIL; - } - - if (!credential_capabilities.is_slot_valid(credential_slot)) { - sl_log_error( - LOG_TAG, - "Credential slot %d is not valid for Credential Type %d. Not " - "starting learn process.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } - - // Check parameters values - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; - } - - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { + // Get the credential type node + auto credential_type_node = endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + if (!credential_type_node.is_valid()) { sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists." - "Not adding credentials.", - credential_slot, + "Can't find Credential Type %d reported by Credential " + "Checksum Report", credential_type); return SL_STATUS_FAIL; } - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - auto credential_type_node - = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), - credential_type); - - // Create credential slot with reported value since we don't want - // to trigger a Credential Get right away - auto credential_slot_node - = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot); - - if (credential_learn_timeout == 0) { - credential_learn_timeout - = credential_capabilities.get_learn_recommended_timeout(); - sl_log_debug(LOG_TAG, - "Credential learn timeout is 0. Setting it to default " - "reported value (%d seconds).", - credential_learn_timeout); - } + credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)) + .set_reported(credential_checksum); - // Set attributes for Credential Learn - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) - .set_reported(credential_learn_timeout); + // Compute checksum ourselves to see if it matches + user_credential::checksum_calculator checksum_calculator; + for_each_credential_type_nodes( + endpoint_node, + [&](auto credential_type_node) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%s reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } - set_credential_learn_operation_type(credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_ADD); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, "Error in credential learn start : %s", e.what()); - return SL_STATUS_FAIL; - } + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); + } + }, + credential_type); - return SL_STATUS_OK; + result = check_checksum_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), + checksum_calculator.compute_checksum(), + credential_checksum); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Checksum Report frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; } - sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout) - { - // Debug info - sl_log_debug( - LOG_TAG, - "zwave_command_class_user_credential_credential_learn_start (modify) " - "called with : "); - sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); - sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); - sl_log_debug(LOG_TAG, - "\tcredential_learn_timeout : %d", - credential_learn_timeout); - - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); + return result; +} - if (!credential_capabilities.is_learn_supported()) { - sl_log_error( - LOG_TAG, - "Learn is not supported for credential type %d. Not starting " - "learn process.", - credential_type); - return SL_STATUS_FAIL; - } +///////////////////////////////////////////////////////////////////////////// +// Post interview actions +///////////////////////////////////////////////////////////////////////////// +void zwave_network_status_changed(attribute_store_node_t node, + attribute_store_change_t change) +{ + // We englobe this in case we can't read an attribute or something goes wrong + try { + attribute_store::attribute network_status_node(node); + auto node_id_node = network_status_node.first_parent(ATTRIBUTE_NODE_ID); - // Check parameters values - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; + // Should not happen but we check anyway to prevent an exception to raise + if (!node_id_node.reported_exists()) { + return; } - if (credential_learn_timeout == 0) { - credential_learn_timeout - = credential_capabilities.get_learn_recommended_timeout(); - sl_log_debug(LOG_TAG, - "Credential learn timeout is 0. Setting it to default " - "reported value (%d seconds).", - credential_learn_timeout); - } + auto node_id = node_id_node.reported(); - try { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {credential_slot, REPORTED_ATTRIBUTE}); - - auto credential_slot_node = nodes.slot_node; - - // Set attributes for Credential Learn - credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) - .set_reported(credential_learn_timeout); - set_credential_learn_operation_type( - credential_slot_node, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error in credential learn start modify : %s", - e.what()); - return SL_STATUS_FAIL; + // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything + if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { + return; } - return SL_STATUS_OK; - } - - sl_status_t zwave_command_class_user_credential_credential_learn_stop( - attribute_store_node_t endpoint_node) - { - uint8_t stop_flag = 1; - - return attribute_store_set_child_desired(endpoint_node, - ATTRIBUTE(CREDENTIAL_LEARN_STOP), - &stop_flag, - sizeof(stop_flag)); - } - - sl_status_t zwave_command_class_user_credential_uuic_association_set( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type, - user_credential_user_unique_id_t source_user_id, - user_credential_slot_t source_credential_slot, - user_credential_user_unique_id_t destination_user_id, - user_credential_slot_t destination_credential_slot) - { - try { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {source_user_id, REPORTED_ATTRIBUTE}, - {credential_type, REPORTED_ATTRIBUTE}, - {source_credential_slot, REPORTED_ATTRIBUTE}); - - nodes.slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)) - .set_desired(destination_user_id); - - // Slot ID last since it's this attribute that is bound to the SET command - nodes.slot_node - .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) - .set_desired(destination_credential_slot); - } catch (std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up uuic asociation set : %s", - e.what()); - return SL_STATUS_FAIL; + // If the endpoint report is marked as ONLINE_FUNCTIONAL + if (network_status_node.reported() + == ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL) { + sl_log_debug(LOG_TAG, + "Node %d is now ONLINE_FUNCTIONAL : start the delayed " + "interview process", + node_id); + // Perform action on each endpoint that supports User Credential Command class + sl_log_debug(LOG_TAG, "Checking endpoints..."); + for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { + auto endpoint_id = endpoint_node.reported(); + // Check if the endpoint supports User Credential Command class + if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, + node_id, + endpoint_id)) { + sl_log_debug(LOG_TAG, + "Endpoint %d supports User Credential.", + endpoint_id); + auto user_count + = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + if (user_count == 0) { + sl_log_debug( + LOG_TAG, + "No user found. Starting User and Credential interview"); + // Start the interview process with user ID = 0 + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(0); + } else { + sl_log_debug(LOG_TAG, + "Users already discovered. No actions needed."); + } + } + } + sl_log_debug(LOG_TAG, "Done."); } - - return SL_STATUS_OK; + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while handling network status change : %s", + e.what()); } +} - sl_status_t zwave_command_class_user_credential_get_user_checksum( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id) - { - try { - auto user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - - auto checksum_node = user_id_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)); - // If node already exists, we clear its value to trigger the GET - checksum_node.clear_reported(); - checksum_node.clear_desired(); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up user get checksum : %s", - e.what()); - return SL_STATUS_FAIL; - } +///////////////////////////////////////////////////////////////////////////// +// Class logic +///////////////////////////////////////////////////////////////////////////// - return SL_STATUS_OK; +// Control handler +sl_status_t zwave_command_class_user_credential_control_handler( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + if (frame_length <= COMMAND_INDEX) { + return SL_STATUS_NOT_SUPPORTED; } - sl_status_t zwave_command_class_user_credential_get_credential_checksum( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type) - { - try { - attribute_store::attribute cpp_endpoint_node(endpoint_node); - auto supported_credential_type_node - = cpp_endpoint_node.child_by_type_and_value( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - credential_type); - - if (!supported_credential_type_node.is_valid()) { - sl_log_error(LOG_TAG, - "Can't find supported credential type %d. Not setting up " - "Checksum get.", - credential_type); - return SL_STATUS_FAIL; - } - - auto checksum_node = supported_credential_type_node.emplace_node( - ATTRIBUTE(CREDENTIAL_CHECKSUM)); - // If node already exists, we clear its value to trigger the GET - checksum_node.clear_reported(); - checksum_node.clear_desired(); - } catch (const std::exception &e) { - sl_log_error(LOG_TAG, - "Error while setting up credential get checksum : %s", - e.what()); - return SL_STATUS_FAIL; - } - - return SL_STATUS_OK; + switch (frame_data[COMMAND_INDEX]) { + case USER_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_user_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_CAPABILITIES_REPORT: + return zwave_command_class_user_credential_credential_capabilities_handle_report( + connection_info, + frame_data, + frame_length); + case ALL_USERS_CHECKSUM_REPORT: + return zwave_command_class_user_credential_all_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); + case USER_REPORT: + return zwave_command_class_user_credential_user_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_REPORT: + return zwave_command_class_user_credential_credential_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_LEARN_REPORT: + return zwave_command_class_user_credential_credential_learn_status_report( + connection_info, + frame_data, + frame_length); + case USER_CREDENTIAL_ASSOCIATION_REPORT: + return zwave_command_class_user_credential_uuic_association_report( + connection_info, + frame_data, + frame_length); + case USER_CHECKSUM_REPORT: + return zwave_command_class_user_credential_user_checksum_handle_report( + connection_info, + frame_data, + frame_length); + case CREDENTIAL_CHECKSUM_REPORT: + return zwave_command_class_user_credential_credential_checksum_handle_report( + connection_info, + frame_data, + frame_length); + default: + return SL_STATUS_NOT_SUPPORTED; } +} - ///////////////////////////////////////////////////////////////////////////// - // Class logic - ///////////////////////////////////////////////////////////////////////////// - - // Control handler - sl_status_t zwave_command_class_user_credential_control_handler( - const zwave_controller_connection_info_t *connection_info, - const uint8_t *frame_data, - uint16_t frame_length) - { - if (frame_length <= COMMAND_INDEX) { - return SL_STATUS_NOT_SUPPORTED; - } +// Entry point +sl_status_t zwave_command_class_user_credential_init() +{ + attribute_store_register_callback_by_type( + &zwave_command_class_user_credential_on_version_attribute_update, + ATTRIBUTE(VERSION)); - switch (frame_data[COMMAND_INDEX]) { - case USER_CAPABILITIES_REPORT: - return zwave_command_class_user_credential_user_capabilities_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_CAPABILITIES_REPORT: - return zwave_command_class_user_credential_credential_capabilities_handle_report( - connection_info, - frame_data, - frame_length); - case ALL_USERS_CHECKSUM_REPORT: - return zwave_command_class_user_credential_all_user_checksum_handle_report( - connection_info, - frame_data, - frame_length); - case USER_REPORT: - return zwave_command_class_user_credential_user_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_REPORT: - return zwave_command_class_user_credential_credential_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_LEARN_REPORT: - return zwave_command_class_user_credential_credential_learn_status_report( - connection_info, - frame_data, - frame_length); - case USER_CREDENTIAL_ASSOCIATION_REPORT: - return zwave_command_class_user_credential_uuic_association_report( - connection_info, - frame_data, - frame_length); - case USER_CHECKSUM_REPORT: - return zwave_command_class_user_credential_user_checksum_handle_report( - connection_info, - frame_data, - frame_length); - case CREDENTIAL_CHECKSUM_REPORT: - return zwave_command_class_user_credential_credential_checksum_handle_report( - connection_info, - frame_data, - frame_length); - default: - return SL_STATUS_NOT_SUPPORTED; - } - } + attribute_resolver_register_rule( + ATTRIBUTE(NUMBER_OF_USERS), + NULL, + &zwave_command_class_user_credential_user_capabilities_get); - // Entry point - sl_status_t zwave_command_class_user_credential_init() - { - attribute_store_register_callback_by_type( - &zwave_command_class_user_credential_on_version_attribute_update, - ATTRIBUTE(VERSION)); - - attribute_resolver_register_rule( - ATTRIBUTE(NUMBER_OF_USERS), - NULL, - &zwave_command_class_user_credential_user_capabilities_get); - - attribute_resolver_register_rule( - ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), - NULL, - &zwave_command_class_user_credential_credential_capabilities_get); - - attribute_resolver_register_rule( - ATTRIBUTE(ALL_USERS_CHECKSUM), - NULL, - &zwave_command_class_user_credential_all_user_checksum_get); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_UNIQUE_ID), - NULL, - &zwave_command_class_user_credential_user_get); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_OPERATION_TYPE), - &zwave_command_class_user_credential_user_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_SLOT), - NULL, - &zwave_command_class_user_credential_credential_get); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), - &zwave_command_class_user_credential_credential_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), - &zwave_command_class_user_credential_credential_learn_start, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_LEARN_STOP), - &zwave_command_class_user_credential_credential_learn_cancel, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), - &zwave_command_class_user_credential_uuic_association_set, - NULL); - - attribute_resolver_register_rule( - ATTRIBUTE(USER_CHECKSUM), - NULL, - &zwave_command_class_user_credential_user_checksum_get); - - attribute_resolver_register_rule( - ATTRIBUTE(CREDENTIAL_CHECKSUM), - NULL, - &zwave_command_class_user_credential_credential_checksum_get); - - // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 - // Discussion about delaying the user interview process after the inclusion - - // Proposed Unify-way to delay users get AFTER interview process - attribute_store_register_callback_by_type( - &zwave_network_status_changed, - DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS); - - zwave_command_handler_t handler = {}; - handler.support_handler = NULL; - handler.control_handler - = zwave_command_class_user_credential_control_handler; - // CHECKME : Is this right ? - handler.minimal_scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS; - handler.manual_security_validation = false; - handler.command_class = COMMAND_CLASS_USER_CREDENTIAL; - handler.version = 1; - handler.command_class_name = "User Credential"; - handler.comments = "Experimental"; - - return zwave_command_handler_register_handler(handler); - } \ No newline at end of file + attribute_resolver_register_rule( + ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_capabilities_get); + + attribute_resolver_register_rule( + ATTRIBUTE(ALL_USERS_CHECKSUM), + NULL, + &zwave_command_class_user_credential_all_user_checksum_get); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_UNIQUE_ID), + NULL, + &zwave_command_class_user_credential_user_get); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_OPERATION_TYPE), + &zwave_command_class_user_credential_user_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_SLOT), + NULL, + &zwave_command_class_user_credential_credential_get); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), + &zwave_command_class_user_credential_credential_learn_start, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &zwave_command_class_user_credential_credential_learn_cancel, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + &zwave_command_class_user_credential_uuic_association_set, + NULL); + + attribute_resolver_register_rule( + ATTRIBUTE(USER_CHECKSUM), + NULL, + &zwave_command_class_user_credential_user_checksum_get); + + attribute_resolver_register_rule( + ATTRIBUTE(CREDENTIAL_CHECKSUM), + NULL, + &zwave_command_class_user_credential_credential_checksum_get); + + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 + // Discussion about delaying the user interview process after the inclusion + + // Proposed Unify-way to delay users get AFTER interview process + attribute_store_register_callback_by_type( + &zwave_network_status_changed, + DOTDOT_ATTRIBUTE_ID_STATE_NETWORK_STATUS); + + zwave_command_handler_t handler = {}; + handler.support_handler = NULL; + handler.control_handler = zwave_command_class_user_credential_control_handler; + // CHECKME : Is this right ? + handler.minimal_scheme = ZWAVE_CONTROLLER_ENCAPSULATION_SECURITY_2_ACCESS; + handler.manual_security_validation = false; + handler.command_class = COMMAND_CLASS_USER_CREDENTIAL; + handler.version = 1; + handler.command_class_name = "User Credential"; + handler.comments = "Experimental"; + + return zwave_command_handler_register_handler(handler); +} \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 71e6b2ef3..098bf776c 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -32,320 +32,6 @@ extern "C" { #endif -/** - * @brief Send a new user command (User SET) to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should NOT exists and NOT be 0 - * @param user_type The type of the user credential. - * @param credential_rule The rule associated with the user credential. - * @param user_active_state The active state of the user. - * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. - * @param user_name_encoding The encoding format of the user name. - * @param user_name The name of the user. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. - */ -sl_status_t zwave_command_class_user_credential_add_new_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name); - - -/** - * @brief Send a modify user command (User SET) to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Should NOT be 0. - * @param user_type The type of the user credential. - * @param credential_rule The rule associated with the user credential. - * @param user_active_state The active state of the user. - * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. - * @param user_name_encoding The encoding format of the user name. - * @param user_name The name of the user. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. - */ -sl_status_t zwave_command_class_user_credential_modify_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t user_type, - user_credential_rule_t credential_rule, - user_credential_user_active_state_t user_active_state, - user_credential_expiring_timeout_minutes_t expiring_timeout, - user_credential_user_name_encoding_t user_name_encoding, - const char *user_name); - -/** - * @brief Send a delete user command (User SET) to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists. -*/ -sl_status_t zwave_command_class_user_credential_delete_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id); - -/** - * @brief Send a new credential command (Credential SET) to the end device - * - * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. - * - PINCode : Refuse any values that is not between '0' and '9'. - * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. - * - Others : Will be stored as is. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Can exist or not. Cannot be 0. - * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. - * @param credential_data Raw data of the credential. Checks are performed based on the credential type. - * - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential data is invalid. - */ -sl_status_t zwave_command_class_user_credential_add_new_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char* credential_data); - -/** - * @brief Send a modify credential command (Credential SET) to the end device - * - * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. - * - PINCode : Refuse any values that is not between '0' and '9'. - * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. - * - Others : Will be stored as is. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Should exists. Cannot be 0. - * @param credential_slot The slot of the credential. Should exists. Cannot be 0. - * @param credential_data Raw data of the credential. Checks are performed based on the credential type. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. Also if the credential data is invalid. - */ -sl_status_t zwave_command_class_user_credential_modify_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const char* credential_data -); - -/** - * @brief Send a delete credential command (Credential SET) to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Should exists. Cannot be 0. - * @param credential_slot The slot of the credential. Should exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. -*/ -sl_status_t zwave_command_class_user_credential_delete_credential( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot); - -/** - * @brief Send a delete all users command (User SET) to the end device - * - * It will send an User SET command with user id = 0 and operation type delete to remove all users. - * (CC:0083.01.05.11.009) - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise -*/ -sl_status_t zwave_command_class_user_credential_delete_all_users( - attribute_store_node_t endpoint_node); - -/** - * @brief Send a delete all credentials command (Credential SET) to the end device - * - * It will send an Credential SET command with user_id, credential_type and credential_slot = 0 and operation type delete to remove all credentials. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise -*/ -sl_status_t zwave_command_class_user_credential_delete_all_credentials( - attribute_store_node_t endpoint_node); - -/** - * @brief Send a delete all credentials by type command (Credential SET) to the end device - * - * It will send an Credential SET command with user_id = 0 and operation type delete to remove all credentials of the specified type. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param credential_type The type of the credential. Should exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise -*/ -sl_status_t - zwave_command_class_user_credential_delete_all_credentials_by_type( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type); - -/** - * @brief Send a delete all credentials for user command (Credential SET) to the end device - * - * It will send an Credential SET command with credential_type and credential_slot = 0 and operation type delete to remove all credentials of the specified user. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise - * - * @note This function will not remove the user itself. - */ -sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id); - -/** - * @brief Send a delete all credentials for user by type command (Credential SET) to the end device - * - * It will send an Credential SET command with credential_slot = 0 and operation type delete to remove all credentials of the specified user and type. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Should exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise - * - * @note This function will not remove the user itself. -*/ -sl_status_t - zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type); - - -/** - * @brief Send new credential command (Credential Learn Start) with operation type Add to the end device - * - * @note The credential type must be supporting the Credential Learn feature. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Can exist or not. Cannot be 0. - * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. - * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential type doesn't support the learn mode. - */ -sl_status_t zwave_command_class_user_credential_credential_learn_start_add( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout); - -/** - * @brief Send new credential command (Credential Learn Start) with operation type Modify to the end device - * - * @note The credential type must be supporting the Credential Learn feature. - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the user. Should exists. Cannot be 0. - * @param credential_type The type of the credential. Should exists. Cannot be 0. - * @param credential_slot The slot of the credential. Should exists. Cannot be 0. - * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot/credential type is 0 or does not exists. Also if the credential type doesn't support the learn mode. - */ -sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id, - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - user_credential_learn_timeout_t credential_learn_timeout); - -/** - * @brief Send new credential command (Credential Learn Stop) to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL otherwise -*/ -sl_status_t zwave_command_class_user_credential_credential_learn_stop( - attribute_store_node_t endpoint_node); - - -/** - * @brief Send a User Unique Identifier Credential Association Set to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param credential_type The type of the credential. - * @param source_user_id The unique ID of the source user. Should exists. Cannot be 0. - * @param source_credential_slot The slot of the source credential. Should exists. Cannot be 0. - * @param destination_user_id The unique ID of the destination user. Cannot be 0. - * @param destination_credential_slot The slot of the destination credential. Should not exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. - */ -sl_status_t zwave_command_class_user_credential_uuic_association_set( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type, - user_credential_user_unique_id_t source_user_id, - user_credential_slot_t source_credential_slot, - user_credential_user_unique_id_t destination_user_id, - user_credential_slot_t destination_credential_slot); - -/** - * @brief Send a User Checksum Get command to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param user_id The unique ID of the source user. Should exists. Cannot be 0. - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. - */ -sl_status_t zwave_command_class_user_credential_get_user_checksum( - attribute_store_node_t endpoint_node, - user_credential_user_unique_id_t user_id); - - -/** - * @brief Send a Credential Checksum Get command to the end device - * - * @param endpoint_node The attribute store node of the endpoint where the user credential is located. - * @param credential_type The type of the credential. Cannot be 0 - * - * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully - * @return sl_status_t SL_STATUS_FAIL if the credential_type is not supported or is 0. - */ -sl_status_t zwave_command_class_user_credential_get_credential_checksum( - attribute_store_node_t endpoint_node, - user_credential_type_t credential_type); - sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp new file mode 100644 index 000000000..0a66b7a77 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -0,0 +1,803 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#include "zwave_command_class_user_credential_api.h" + +#include "private/user_credential/user_credential_helpers.hpp" +#include "private/user_credential/user_credential_user_capabilities.h" +#include "private/user_credential/user_credential_credential_capabilities.h" + +#include + +using namespace user_credential_helpers; + + +///////////////////////////////////////////////////////////////////////////// +// Attributes helpers +///////////////////////////////////////////////////////////////////////////// + +/** + * @brief Updates the desired values of attributes in the attribute store. + * + * This function takes a map of attribute values and their corresponding sizes, and updates the desired values + * of the attributes in the attribute store. + * The attribute store is updated for the specified parent node. + * + * @param attribute_map_values A map containing the attribute values and their sizes. + * @param parent_node The parent node of values that will be updated + * + * @return SL_STATUS_OK if the desired values were updated successfully, an otherwise an error code. + */ +sl_status_t update_desired_values( + attribute_store_node_t parent_node, + std::map> + attribute_map_values) +{ + sl_status_t status = SL_STATUS_OK; + for (auto &attr: attribute_map_values) { + auto value = attr.second.first; + auto value_size = attr.second.second; + + if (attribute_store_get_storage_type(attr.first) == C_STRING_STORAGE_TYPE) { + auto str_attribute_node + = attribute_store_get_node_child_by_type(parent_node, attr.first, 0); + auto value_str = static_cast(value); + sl_log_debug(LOG_TAG, + "Update desired value of %s to %s", + attribute_store_get_type_name(attr.first), + value_str); + status + |= attribute_store_set_desired_string(str_attribute_node, value_str); + } else { + sl_log_debug(LOG_TAG, + "Update desired value of %s", + attribute_store_get_type_name(attr.first)); + status |= attribute_store_set_child_desired(parent_node, + attr.first, + value, + value_size); + } + + if (status != SL_STATUS_OK) { + sl_log_error(LOG_TAG, + "Error while setting desired value of %s", + attribute_store_get_type_name(attr.first)); + } + } + + return status; +} + +///////////////////////////////////////////////////////////////////////////// +// Exposed class functions +///////////////////////////////////////////////////////////////////////////// + +sl_status_t zwave_command_class_user_credential_add_new_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) +{ + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); + return SL_STATUS_FAIL; + } + + // Node already exists, can't create user. + if (user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d already exists. Not adding user.", + user_id); + return SL_STATUS_FAIL; + } + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } + + // Create the user node + auto user_id_node = attribute_store_emplace_desired(endpoint_node, + ATTRIBUTE(USER_UNIQUE_ID), + &user_id, + sizeof(user_id)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_TYPE), + &user_type, + sizeof(user_type)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(CREDENTIAL_RULE), + &credential_rule, + sizeof(credential_rule)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_ACTIVE_STATE), + &user_active_state, + sizeof(user_active_state)); + + if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + if (expiring_timeout != 0) { + sl_log_warning( + LOG_TAG, + "Expiring timeout set for non-expiring user, set value to 0."); + } + expiring_timeout = 0; + } + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + &expiring_timeout, + sizeof(expiring_timeout)); + + attribute_store_emplace_desired(user_id_node, + ATTRIBUTE(USER_NAME_ENCODING), + &user_name_encoding, + sizeof(user_name_encoding)); + // User name node + auto user_name_node + = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); + attribute_store_set_desired_string(user_name_node, user_name); + + // Finally set operation type add + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); + + sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + if (!user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Not deleting user.", + user_id); + return SL_STATUS_FAIL; + } + + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + // Finally set operation type delete + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_modify_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name) +{ + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); + return SL_STATUS_FAIL; + } + + if (!user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Can't modify user.", + user_id); + return SL_STATUS_FAIL; + } + + // Check if the user already exists + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tuser_type : %d", user_type); + sl_log_debug(LOG_TAG, "\tcredential_rule : %d", credential_rule); + sl_log_debug(LOG_TAG, "\tuser_active_state : %d", user_active_state); + sl_log_debug(LOG_TAG, "\texpiring_timeout : %d", expiring_timeout); + sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); + sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); + + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } + + std::map> values = { + {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, + {ATTRIBUTE(CREDENTIAL_RULE), {&credential_rule, sizeof(credential_rule)}}, + {ATTRIBUTE(USER_ACTIVE_STATE), + {&user_active_state, sizeof(user_active_state)}}, + {ATTRIBUTE(USER_NAME_ENCODING), + {&user_name_encoding, sizeof(user_name_encoding)}}, + {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, + }; + + // Only add expiring timeout if user is expiring + if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), + {&expiring_timeout, sizeof(expiring_timeout)}}); + } + + // Update values based on the map + sl_status_t status = update_desired_values(user_id_node, values); + // If everything went well set operation type to modify + if (status == SL_STATUS_OK) { + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); + } else { + sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); + } + + return status; +} + +sl_status_t zwave_command_class_user_credential_add_new_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) +{ + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_add_new_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Check if parameters are ok + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + auto capabilities + = user_credential::credential_capabilities(endpoint_node, credential_type); + + if (!capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d is not valid. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Get or create credential type node + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + + // Process credential data + std::vector credential_data_vector + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); + + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data_vector, + DESIRED_ATTRIBUTE); + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to add a new credential : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_modify_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char *credential_data) +{ + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_modify_credential called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); + + // Check if parameters are ok + if (user_id == 0 || credential_type == 0 || credential_slot == 0) { + sl_log_error(LOG_TAG, + "User ID, Credential Type and Slot 0 are reserved. Not " + "modifying credentials."); + return SL_STATUS_FAIL; + } + + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + // Get current credential slot node + auto credential_slot_node = nodes.slot_node; + // Process credential data + auto capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); + std::vector credential_data_vector + = capabilities.convert_and_validate_credential_data(credential_data, + credential_slot); + // Modify current data + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA)) + .set_desired(credential_data_vector); + + // Finally set operation type modify + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to modify a credential : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + sl_log_debug(LOG_TAG, + "Delete credential slot %d (credential type %d, user id %d)", + credential_slot, + credential_type, + user_id); + + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + // Finally set operation type delete + set_credential_operation_type(nodes.slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while trying to delete a credential : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_all_users( + attribute_store_node_t endpoint_node) +{ + attribute_store::attribute cpp_endpoint_node(endpoint_node); + user_credential_user_unique_id_t user_id = 0; + auto user_id_node + = cpp_endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Finally set operation type delete + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, + "Delete all user operation received. Creating user with id %d " + "to send a User SET.", + user_id); + return SL_STATUS_OK; +} + +void trigger_credential_deletion(attribute_store::attribute endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot) +{ + auto credential_slot_node + = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id) + .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type) + .emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), credential_slot); + + // Finally set operation type delete + set_credential_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + + sl_log_debug(LOG_TAG, + "Creating user with id %d, credential type %d and slot " + "both to %d to send a Credential SET.", + user_id, + credential_type, + credential_slot); +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials( + attribute_store_node_t endpoint_node) +{ + sl_log_debug(LOG_TAG, "Delete all credential operation received"); + + trigger_credential_deletion(endpoint_node, 0, 0, 0); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials_by_type( + attribute_store_node_t endpoint_node, user_credential_type_t credential_type) +{ + sl_log_debug(LOG_TAG, + "Delete all credential of type %d operation received", + credential_type); + + trigger_credential_deletion(endpoint_node, 0, credential_type, 0); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + sl_log_debug(LOG_TAG, + "Delete all credential for user %d operation received", + user_id); + + trigger_credential_deletion(endpoint_node, user_id, 0, 0); + + return SL_STATUS_OK; +} + +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type) +{ + sl_log_debug(LOG_TAG, + "Delete all credential for user %d and credential type %d " + "operation received", + user_id, + credential_type); + + trigger_credential_deletion(endpoint_node, user_id, credential_type, 0); + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_start_add( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) +{ + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (Add)" + " called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + + auto credential_capabilities + = user_credential::credential_capabilities(endpoint_node, credential_type); + + if (!credential_capabilities.is_learn_supported()) { + sl_log_error(LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } + + if (!credential_capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d is not valid for Credential Type %d. Not " + "starting learn process.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } + + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + auto credential_type_node + = user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + + // Create credential slot with reported value since we don't want + // to trigger a Credential Get right away + auto credential_slot_node + = credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.get_learn_recommended_timeout(); + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } + + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); + + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error in credential learn start : %s", e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout) +{ + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_credential_learn_start (modify) " + "called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); + sl_log_debug(LOG_TAG, "\tcredential_type : %d", credential_type); + sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); + sl_log_debug(LOG_TAG, + "\tcredential_learn_timeout : %d", + credential_learn_timeout); + + auto credential_capabilities + = user_credential::credential_capabilities(endpoint_node, credential_type); + + if (!credential_capabilities.is_learn_supported()) { + sl_log_error(LOG_TAG, + "Learn is not supported for credential type %d. Not starting " + "learn process.", + credential_type); + return SL_STATUS_FAIL; + } + + // Check parameters values + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } + + if (credential_learn_timeout == 0) { + credential_learn_timeout + = credential_capabilities.get_learn_recommended_timeout(); + sl_log_debug(LOG_TAG, + "Credential learn timeout is 0. Setting it to default " + "reported value (%d seconds).", + credential_learn_timeout); + } + + try { + auto nodes + = get_credential_identifier_nodes(endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + auto credential_slot_node = nodes.slot_node; + + // Set attributes for Credential Learn + credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_TIMEOUT)) + .set_reported(credential_learn_timeout); + set_credential_learn_operation_type(credential_slot_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error in credential learn start modify : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_credential_learn_stop( + attribute_store_node_t endpoint_node) +{ + uint8_t stop_flag = 1; + + return attribute_store_set_child_desired(endpoint_node, + ATTRIBUTE(CREDENTIAL_LEARN_STOP), + &stop_flag, + sizeof(stop_flag)); +} + +sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_user_unique_id_t source_user_id, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot) +{ + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {source_user_id, REPORTED_ATTRIBUTE}, + {credential_type, REPORTED_ATTRIBUTE}, + {source_credential_slot, REPORTED_ATTRIBUTE}); + + nodes.slot_node.emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID)) + .set_desired(destination_user_id); + + // Slot ID last since it's this attribute that is bound to the SET command + nodes.slot_node + .emplace_node(ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT)) + .set_desired(destination_credential_slot); + } catch (std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up uuic asociation set : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_get_user_checksum( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + try { + auto user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + auto checksum_node = user_id_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up user get checksum : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +sl_status_t zwave_command_class_user_credential_get_credential_checksum( + attribute_store_node_t endpoint_node, user_credential_type_t credential_type) +{ + try { + attribute_store::attribute cpp_endpoint_node(endpoint_node); + auto supported_credential_type_node + = cpp_endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + + if (!supported_credential_type_node.is_valid()) { + sl_log_error(LOG_TAG, + "Can't find supported credential type %d. Not setting up " + "Checksum get.", + credential_type); + return SL_STATUS_FAIL; + } + + auto checksum_node = supported_credential_type_node.emplace_node( + ATTRIBUTE(CREDENTIAL_CHECKSUM)); + // If node already exists, we clear its value to trigger the GET + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up credential get checksum : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h new file mode 100644 index 000000000..90a0c39df --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h @@ -0,0 +1,353 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +/** + * @defgroup zwave_command_class_user_credential_api + * @brief User Credential Command Class High Level API + * + * @see zwave_command_class_user_credential for interaction with zwave frames and end device + * + */ + +#ifndef ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_API_H +#define ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_API_H + +#include "sl_status.h" +#include "zwave_command_class_user_credential_types.h" +#include "attribute_store.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Send a new user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should NOT exists and NOT be 0 + * @param user_type The type of the user credential. + * @param credential_rule The rule associated with the user credential. + * @param user_active_state The active state of the user. + * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. + * @param user_name_encoding The encoding format of the user name. + * @param user_name The name of the user. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_add_new_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name); + + +/** + * @brief Send a modify user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Should NOT be 0. + * @param user_type The type of the user credential. + * @param credential_rule The rule associated with the user credential. + * @param user_active_state The active state of the user. + * @param expiring_timeout The timeout for the user credential to expire, in minutes. Will be ignored unless user_type == 0x07. + * @param user_name_encoding The encoding format of the user name. + * @param user_name The name of the user. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_modify_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + const char *user_name); + +/** + * @brief Send a delete user command (User SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists. +*/ +sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + +/** + * @brief Send a new credential command (Credential SET) to the end device + * + * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. + * - PINCode : Refuse any values that is not between '0' and '9'. + * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. + * - Others : Will be stored as is. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Can exist or not. Cannot be 0. + * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. + * @param credential_data Raw data of the credential. Checks are performed based on the credential type. + * + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential data is invalid. + */ +sl_status_t zwave_command_class_user_credential_add_new_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char* credential_data); + +/** + * @brief Send a modify credential command (Credential SET) to the end device + * + * The credential data expected is an UTF-8 string. Some check/conversion will be performed based on the credential type. + * - PINCode : Refuse any values that is not between '0' and '9'. + * - Password : Will be stored in UTF-16 format. The exposed value still be in UTF-8, but the end device will receive UTF-16 data. + * - Others : Will be stored as is. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * @param credential_data Raw data of the credential. Checks are performed based on the credential type. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. Also if the credential data is invalid. + */ +sl_status_t zwave_command_class_user_credential_modify_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const char* credential_data +); + +/** + * @brief Send a delete credential command (Credential SET) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id, credential type or credential slot doesn't exists or one of the value is 0. +*/ +sl_status_t zwave_command_class_user_credential_delete_credential( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot); + +/** + * @brief Send a delete all users command (User SET) to the end device + * + * It will send an User SET command with user id = 0 and operation type delete to remove all users. + * (CC:0083.01.05.11.009) + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_delete_all_users( + attribute_store_node_t endpoint_node); + +/** + * @brief Send a delete all credentials command (Credential SET) to the end device + * + * It will send an Credential SET command with user_id, credential_type and credential_slot = 0 and operation type delete to remove all credentials. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_delete_all_credentials( + attribute_store_node_t endpoint_node); + +/** + * @brief Send a delete all credentials by type command (Credential SET) to the end device + * + * It will send an Credential SET command with user_id = 0 and operation type delete to remove all credentials of the specified type. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_by_type( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type); + +/** + * @brief Send a delete all credentials for user command (Credential SET) to the end device + * + * It will send an Credential SET command with credential_type and credential_slot = 0 and operation type delete to remove all credentials of the specified user. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise + * + * @note This function will not remove the user itself. + */ +sl_status_t zwave_command_class_user_credential_delete_all_credentials_for_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + +/** + * @brief Send a delete all credentials for user by type command (Credential SET) to the end device + * + * It will send an Credential SET command with credential_slot = 0 and operation type delete to remove all credentials of the specified user and type. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise + * + * @note This function will not remove the user itself. +*/ +sl_status_t + zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type); + + +/** + * @brief Send new credential command (Credential Learn Start) with operation type Add to the end device + * + * @note The credential type must be supporting the Credential Learn feature. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Can exist or not. Cannot be 0. + * @param credential_slot The slot of the credential. Should not exists. Cannot be 0. + * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot already exists or one of the value is 0. Also if the credential type doesn't support the learn mode. + */ +sl_status_t zwave_command_class_user_credential_credential_learn_start_add( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout); + +/** + * @brief Send new credential command (Credential Learn Start) with operation type Modify to the end device + * + * @note The credential type must be supporting the Credential Learn feature. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the user. Should exists. Cannot be 0. + * @param credential_type The type of the credential. Should exists. Cannot be 0. + * @param credential_slot The slot of the credential. Should exists. Cannot be 0. + * @param credential_learn_timeout Timeout for each credential learn step on the node, in seconds. Can be set to 0 to use recommended timeout by the end device. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or the credential_slot/credential type is 0 or does not exists. Also if the credential type doesn't support the learn mode. + */ +sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id, + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + user_credential_learn_timeout_t credential_learn_timeout); + +/** + * @brief Send new credential command (Credential Learn Stop) to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise +*/ +sl_status_t zwave_command_class_user_credential_credential_learn_stop( + attribute_store_node_t endpoint_node); + + +/** + * @brief Send a User Unique Identifier Credential Association Set to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. + * @param source_user_id The unique ID of the source user. Should exists. Cannot be 0. + * @param source_credential_slot The slot of the source credential. Should exists. Cannot be 0. + * @param destination_user_id The unique ID of the destination user. Cannot be 0. + * @param destination_credential_slot The slot of the destination credential. Should not exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id already exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_uuic_association_set( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type, + user_credential_user_unique_id_t source_user_id, + user_credential_slot_t source_credential_slot, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot); + +/** + * @brief Send a User Checksum Get command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param user_id The unique ID of the source user. Should exists. Cannot be 0. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the user_id doesn't exists or is 0. + */ +sl_status_t zwave_command_class_user_credential_get_user_checksum( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id); + + +/** + * @brief Send a Credential Checksum Get command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_type The type of the credential. Cannot be 0 + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the credential_type is not supported or is 0. + */ +sl_status_t zwave_command_class_user_credential_get_credential_checksum( + attribute_store_node_t endpoint_node, + user_credential_type_t credential_type); + + +#ifdef __cplusplus +} +#endif + +#endif //ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_API_H + /** @} end zwave_command_class_user_credential */ \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index f761bba5d..7404a3309 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -22,6 +22,7 @@ using namespace zwave_command_class_test_helper; extern "C" { #include "zwave_command_class_user_credential.h" +#include "zwave_command_class_user_credential_api.h" #include "zwave_command_class_user_credential_types.h" #include "zwave_command_classes_utils.h" #include "unity.h" From ff8c0de5860a5ac84928f418650a8f5d0e50ad34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 3 Sep 2024 14:36:35 +0200 Subject: [PATCH 41/60] UIC-3222: Refactor User Credential API Use new C++ api to be more consistent --- .../zwave_command_class_user_credential.cpp | 1 - ...wave_command_class_user_credential_api.cpp | 375 ++++++++---------- 2 files changed, 168 insertions(+), 208 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index e7c3975b0..0e1a8b442 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -192,7 +192,6 @@ static sl_status_t return frame_generator.generate_no_args_frame(CREDENTIAL_CAPABILITIES_GET, frame, frame_length); - ; } sl_status_t diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp index 0a66b7a77..b556b3c10 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -13,77 +13,45 @@ #include "zwave_command_class_user_credential_api.h" +// Private definitions #include "private/user_credential/user_credential_helpers.hpp" #include "private/user_credential/user_credential_user_capabilities.h" #include "private/user_credential/user_credential_credential_capabilities.h" +// Cpp includes #include +#include using namespace user_credential_helpers; - -///////////////////////////////////////////////////////////////////////////// -// Attributes helpers -///////////////////////////////////////////////////////////////////////////// - /** - * @brief Updates the desired values of attributes in the attribute store. - * - * This function takes a map of attribute values and their corresponding sizes, and updates the desired values - * of the attributes in the attribute store. - * The attribute store is updated for the specified parent node. - * - * @param attribute_map_values A map containing the attribute values and their sizes. - * @param parent_node The parent node of values that will be updated + * @brief Setup user attributes (desired values) * - * @return SL_STATUS_OK if the desired values were updated successfully, an otherwise an error code. + * This function sets the desired values of the user attributes in the attribute store. + * If attributes are not present, they are created. */ -sl_status_t update_desired_values( - attribute_store_node_t parent_node, - std::map> - attribute_map_values) +void setup_user(attribute_store::attribute user_id_node, + user_credential_type_t user_type, + user_credential_rule_t credential_rule, + user_credential_user_active_state_t user_active_state, + user_credential_expiring_timeout_minutes_t expiring_timeout, + user_credential_user_name_encoding_t user_name_encoding, + std::string user_name) { - sl_status_t status = SL_STATUS_OK; - for (auto &attr: attribute_map_values) { - auto value = attr.second.first; - auto value_size = attr.second.second; - - if (attribute_store_get_storage_type(attr.first) == C_STRING_STORAGE_TYPE) { - auto str_attribute_node - = attribute_store_get_node_child_by_type(parent_node, attr.first, 0); - auto value_str = static_cast(value); - sl_log_debug(LOG_TAG, - "Update desired value of %s to %s", - attribute_store_get_type_name(attr.first), - value_str); - status - |= attribute_store_set_desired_string(str_attribute_node, value_str); - } else { - sl_log_debug(LOG_TAG, - "Update desired value of %s", - attribute_store_get_type_name(attr.first)); - status |= attribute_store_set_child_desired(parent_node, - attr.first, - value, - value_size); - } - - if (status != SL_STATUS_OK) { - sl_log_error(LOG_TAG, - "Error while setting desired value of %s", - attribute_store_get_type_name(attr.first)); - } - } - - return status; + user_id_node.emplace_node(ATTRIBUTE(USER_TYPE)).set_desired(user_type); + user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_RULE)) + .set_desired(credential_rule); + user_id_node.emplace_node(ATTRIBUTE(USER_ACTIVE_STATE)) + .set_desired(user_active_state); + user_id_node.emplace_node(ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES)) + .set_desired(expiring_timeout); + user_id_node.emplace_node(ATTRIBUTE(USER_NAME_ENCODING)) + .set_desired(user_name_encoding); + user_id_node.emplace_node(ATTRIBUTE(USER_NAME)).set_desired(user_name); } -///////////////////////////////////////////////////////////////////////////// -// Exposed class functions -///////////////////////////////////////////////////////////////////////////// - sl_status_t zwave_command_class_user_credential_add_new_user( - attribute_store_node_t endpoint_node, + attribute_store_node_t node, user_credential_user_unique_id_t user_id, user_credential_type_t user_type, user_credential_rule_t credential_rule, @@ -92,21 +60,7 @@ sl_status_t zwave_command_class_user_credential_add_new_user( user_credential_user_name_encoding_t user_name_encoding, const char *user_name) { - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); - return SL_STATUS_FAIL; - } - - // Node already exists, can't create user. - if (user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d already exists. Not adding user.", - user_id); - return SL_STATUS_FAIL; - } - - // Debug info + // Debug info sl_log_debug( LOG_TAG, "zwave_command_class_user_credential_add_new_user called with : "); @@ -118,65 +72,65 @@ sl_status_t zwave_command_class_user_credential_add_new_user( sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); + + auto endpoint_node = attribute_store::attribute(node); + + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Not adding user."); return SL_STATUS_FAIL; } - // Create the user node - auto user_id_node = attribute_store_emplace_desired(endpoint_node, - ATTRIBUTE(USER_UNIQUE_ID), - &user_id, - sizeof(user_id)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_TYPE), - &user_type, - sizeof(user_type)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(CREDENTIAL_RULE), - &credential_rule, - sizeof(credential_rule)); - - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_ACTIVE_STATE), - &user_active_state, - sizeof(user_active_state)); - - if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - if (expiring_timeout != 0) { - sl_log_warning( - LOG_TAG, - "Expiring timeout set for non-expiring user, set value to 0."); - } - expiring_timeout = 0; + // Node already exists, can't create user. + if (user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d already exists. Not adding user.", + user_id); + return SL_STATUS_FAIL; } - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - &expiring_timeout, - sizeof(expiring_timeout)); + try { + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, + "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } - attribute_store_emplace_desired(user_id_node, - ATTRIBUTE(USER_NAME_ENCODING), - &user_name_encoding, - sizeof(user_name_encoding)); - // User name node - auto user_name_node - = attribute_store_add_node(ATTRIBUTE(USER_NAME), user_id_node); - attribute_store_set_desired_string(user_name_node, user_name); + if (user_type != USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { + if (expiring_timeout != 0) { + sl_log_warning( + LOG_TAG, + "Expiring timeout set for non-expiring user, set value to 0."); + } + expiring_timeout = 0; + } - // Finally set operation type add - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); + // Create the user node + auto user_id_node = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + // Create user attributes + setup_user(user_id_node, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name); + + // Finally set operation type add + set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_ADD); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error while adding user : %s", e.what()); + return SL_STATUS_FAIL; + } sl_log_debug(LOG_TAG, "Add user with ID %d", user_id); - return SL_STATUS_OK; } @@ -184,19 +138,30 @@ sl_status_t zwave_command_class_user_credential_delete_user( attribute_store_node_t endpoint_node, user_credential_user_unique_id_t user_id) { - if (!user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d doesn't exists. Not deleting user.", - user_id); - return SL_STATUS_FAIL; - } + // Debug info + sl_log_debug( + LOG_TAG, + "zwave_command_class_user_credential_delete_user called with : "); + sl_log_debug(LOG_TAG, "\tuser_id : %d", user_id); - attribute_store_node_t user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + try { + if (!user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Not deleting user.", + user_id); + return SL_STATUS_FAIL; + } - // Finally set operation type delete - set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_DELETE); + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + // Finally set operation type delete + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_DELETE); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error while deleting user : %s", e.what()); + return SL_STATUS_FAIL; + } sl_log_debug(LOG_TAG, "Remove user with ID %d", user_id); return SL_STATUS_OK; @@ -212,23 +177,6 @@ sl_status_t zwave_command_class_user_credential_modify_user( user_credential_user_name_encoding_t user_name_encoding, const char *user_name) { - // Check user id - if (user_id == 0) { - sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); - return SL_STATUS_FAIL; - } - - if (!user_exists(endpoint_node, user_id)) { - sl_log_error(LOG_TAG, - "User with ID %d doesn't exists. Can't modify user.", - user_id); - return SL_STATUS_FAIL; - } - - // Check if the user already exists - attribute_store_node_t user_id_node - = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - // Debug info sl_log_debug( LOG_TAG, @@ -241,44 +189,56 @@ sl_status_t zwave_command_class_user_credential_modify_user( sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - // Check capabilites - auto capabilites = user_credential::user_capabilities(endpoint_node); - if (!capabilites.is_user_valid(user_id, - user_type, - credential_rule, - user_name)) { - sl_log_error(LOG_TAG, "User capabilities are not valid. Not adding user."); - return SL_STATUS_FAIL; - } + try { + // Check user id + if (user_id == 0) { + sl_log_error(LOG_TAG, "User ID 0 is reserved. Can't modify user."); + return SL_STATUS_FAIL; + } - std::map> values = { - {ATTRIBUTE(USER_TYPE), {&user_type, sizeof(user_type)}}, - {ATTRIBUTE(CREDENTIAL_RULE), {&credential_rule, sizeof(credential_rule)}}, - {ATTRIBUTE(USER_ACTIVE_STATE), - {&user_active_state, sizeof(user_active_state)}}, - {ATTRIBUTE(USER_NAME_ENCODING), - {&user_name_encoding, sizeof(user_name_encoding)}}, - {ATTRIBUTE(USER_NAME), {user_name, sizeof(user_name)}}, - }; - - // Only add expiring timeout if user is expiring - if (user_type == USER_CREDENTIAL_USER_TYPE_EXPIRING_USER) { - values.insert({ATTRIBUTE(USER_EXPIRING_TIMEOUT_MINUTES), - {&expiring_timeout, sizeof(expiring_timeout)}}); - } + if (!user_exists(endpoint_node, user_id)) { + sl_log_error(LOG_TAG, + "User with ID %d doesn't exists. Can't modify user.", + user_id); + return SL_STATUS_FAIL; + } + + // Check if the user already exists + attribute_store_node_t user_id_node + = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); + + // Check capabilites + auto capabilites = user_credential::user_capabilities(endpoint_node); + if (!capabilites.is_user_valid(user_id, + user_type, + credential_rule, + user_name)) { + sl_log_error(LOG_TAG, + "User capabilities are not valid. Not adding user."); + return SL_STATUS_FAIL; + } + + // Modify user attributes + setup_user(user_id_node, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name); - // Update values based on the map - sl_status_t status = update_desired_values(user_id_node, values); - // If everything went well set operation type to modify - if (status == SL_STATUS_OK) { set_user_operation_type(user_id_node, USER_CREDENTIAL_OPERATION_TYPE_MODIFY); sl_log_debug(LOG_TAG, "Modify user with ID %d", user_id); - } else { - sl_log_error(LOG_TAG, "Can't modify user with ID %d", user_id); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while modifying user %d : %s", + user_id, + e.what()); + return SL_STATUS_FAIL; } - return status; + return SL_STATUS_OK; } sl_status_t zwave_command_class_user_credential_add_new_credential( @@ -297,38 +257,39 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( sl_log_debug(LOG_TAG, "\tcredential_slot : %d", credential_slot); sl_log_debug(LOG_TAG, "\tcredential_data : %s", credential_data); - // Check if parameters are ok - if (credential_type == 0 || credential_slot == 0) { - sl_log_error( - LOG_TAG, - "Credential Type and Slot 0 are reserved. Not adding credentials."); - return SL_STATUS_FAIL; - } + try { + // Check if parameters are ok + if (credential_type == 0 || credential_slot == 0) { + sl_log_error( + LOG_TAG, + "Credential Type and Slot 0 are reserved. Not adding credentials."); + return SL_STATUS_FAIL; + } - auto capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + auto capabilities + = user_credential::credential_capabilities(endpoint_node, + credential_type); - if (!capabilities.is_slot_valid(credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d is not valid. " - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + if (!capabilities.is_slot_valid(credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d is not valid. " + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { - sl_log_error(LOG_TAG, - "Credential slot %d for Credential Type %d already exists." - "Not adding credentials.", - credential_slot, - credential_type); - return SL_STATUS_FAIL; - } + if (!is_credential_available(endpoint_node, + credential_type, + credential_slot)) { + sl_log_error(LOG_TAG, + "Credential slot %d for Credential Type %d already exists." + "Not adding credentials.", + credential_slot, + credential_type); + return SL_STATUS_FAIL; + } - try { auto user_id_node = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); // Get or create credential type node From 14d7dc224c038b215545258e1e3640373eb5eb8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 5 Sep 2024 15:59:57 +0200 Subject: [PATCH 42/60] UIC-3222: Fix credential discovery 0 nodes are better handled Credential node are properly deleted when no credential is available --- .../zwave_command_class_user_credential.cpp | 52 ++++++++++++++----- ...ave_command_class_user_credential_test.cpp | 11 ---- 2 files changed, 38 insertions(+), 25 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 0e1a8b442..8c9c1c034 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -475,13 +475,6 @@ static sl_status_t zwave_command_class_user_credential_credential_get( frame_generator.add_value(cred_nodes.type_node, REPORTED_ATTRIBUTE); frame_generator.add_value(cred_nodes.slot_node, DESIRED_ATTRIBUTE); frame_generator.validate_frame(frame_length); - - // Delete special nodes (start interview of credentials) - if (cred_nodes.type_node.reported() == 0 - && cred_nodes.slot_node.desired() == 0) { - cred_nodes.type_node.delete_node(); - cred_nodes.slot_node.delete_node(); - } } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while generating Credential Get frame : %s", @@ -675,14 +668,43 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return SL_STATUS_OK; // Update desired value if found, otherwise create the nodes case credential_report_type_t::RESPONSE_TO_GET: + // First check if this is the first credential interview credential_type_node - = create_or_update_desired_value(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - credential_type); - credential_slot_node - = create_or_update_desired_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot); + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + 0, + REPORTED_ATTRIBUTE); + credential_slot_node = credential_type_node.child_by_type_and_value( + ATTRIBUTE(CREDENTIAL_SLOT), + 0, + DESIRED_ATTRIBUTE); + // Update the values of the first nodes if present + if (credential_type_node.is_valid() + && credential_slot_node.is_valid()) { + // If no credential are reported, we can delete the nodes + if (credential_type == 0 && credential_slot == 0) { + sl_log_debug(LOG_TAG, "No credential to get for user %d", user_id); + credential_type_node.delete_node(); + credential_slot_node.delete_node(); + return SL_STATUS_OK; + } else { + sl_log_debug(LOG_TAG, + "First credential : Updating credential type and slot for user %d", + user_id); + credential_type_node.set_reported(credential_type); + credential_slot_node.clear_desired(); + credential_slot_node.set_reported(credential_slot); + } + } else { + // Otherwise create or get the nodes + credential_type_node + = create_or_update_desired_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + credential_slot_node + = create_or_update_desired_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + } break; case credential_report_type_t::CREDENTIAL_ADD_REJECTED_LOCATION_OCCUPIED: sl_log_error(LOG_TAG, @@ -809,6 +831,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( trigger_get_credential(user_id_node, next_credential_type, next_credential_slot); + } else { + sl_log_debug(LOG_TAG, "No more credential to get."); } } catch (const std::exception &e) { diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 7404a3309..74f5125d4 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1349,17 +1349,6 @@ void test_user_credential_credential_report_happy_case() next_credential_slot); // Test values - TEST_ASSERT_FALSE_MESSAGE(first_credential_type_node.is_valid(), - "Credential type node 0 should have been deleted"); - TEST_ASSERT_FALSE_MESSAGE(first_credential_slot_node.is_valid(), - "Credential slot node 0 should have been deleted"); - - first_credential_type_node - = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_TYPE), user_id_node); - first_credential_slot_node - = helper_test_and_get_node(ATTRIBUTE(CREDENTIAL_SLOT), - first_credential_type_node); - test_credential_values(first_credential_type_node, first_credential_slot_node); // We should have 1 credential type and 2 credential slot From 5619c758eede2ef4ed7937b34b8cf356dc5e5d46 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Fri, 6 Sep 2024 11:31:17 +0200 Subject: [PATCH 43/60] UIC-3222: Better handling of duplicate credential --- .../zwave_command_class_user_credential.cpp | 56 +++++++++++++++++-- ...ave_command_class_user_credential_test.cpp | 8 ++- 2 files changed, 55 insertions(+), 9 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 8c9c1c034..e010203e4 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -608,6 +608,10 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( {credential_slot, DESIRED_ATTRIBUTE}); nodes.slot_node.delete_node(); + sl_log_debug(LOG_TAG, "Cleaning temporary credential slot node : %d (credential type %d, user %d)", + credential_slot, + credential_type, + user_id); }; // We should have a valid user id if we receive this report @@ -746,18 +750,57 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( credential_slot_node.delete_node(); return SL_STATUS_OK; // Duplicate Credential : 0x02 - case credential_report_type_t::CREDENTIAL_DUPLICATE_ERROR: + case credential_report_type_t::CREDENTIAL_DUPLICATE_ERROR: { // Do nothing, the credential GET will clean up for us sl_log_warning(LOG_TAG, - "Duplicate Credential for user %d, credential type %d, " - "credential slot %d", + "Duplicate Credential (Already present for user %d, " + "credential type %d, " + "credential slot %d)", user_id, credential_type, credential_slot); - // This should contains the duplicated credential - clean_up_pending_credentials_slot_nodes(); - return SL_STATUS_OK; + // So this is the fun part when we hunt down the faulty credential slot node + parser.read_byte(); // We don't care about this one + uint8_t cred_data_size = parser.read_byte(); + auto duplicate_data + = parser.read_sequential>(cred_data_size); + + bool found_duplicate = false; + // We need to find the credential slot node that contains the same data + for_each_credential_type_nodes( + endpoint_node, + [&](attribute_store::attribute &credential_type_node) { + for (auto &credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (credential_slot_node.desired_exists()) { + auto current_data + = credential_slot_node + .child_by_type(ATTRIBUTE(CREDENTIAL_DATA)) + .get>(DESIRED_OR_REPORTED_ATTRIBUTE); + if (current_data == duplicate_data) { + sl_log_debug( + LOG_TAG, + "Found the faulty credential slot node : %d", + credential_slot_node.desired()); + credential_slot_node.delete_node(); + found_duplicate = true; + return; + } + } + } + }, + credential_type); + + if (!found_duplicate) { + // If we are here that means we din't find the duplicate data + sl_log_error(LOG_TAG, + "Couldn't find the duplicate credential slot node."); + return SL_STATUS_FAIL; + } else { + return SL_STATUS_OK; + } + } case credential_report_type_t::CREDENTIAL_MANUFACTURER_SECURITY_RULE: sl_log_warning( LOG_TAG, @@ -808,6 +851,7 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( parser.read_byte_with_bitmask( {CREDENTIAL_REPORT_PROPERTIES1_CRB_BIT_MASK, credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_READ_BACK))}); + uint8_t cred_data_size = parser.read_byte(); parser.read_sequential>( cred_data_size, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 74f5125d4..83587409b 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2412,9 +2412,11 @@ void test_user_credential_credential_modify_capabilites_failure_cases() void helper_test_credential_rejected_case(uint8_t report_type) { - user_credential_user_unique_id_t user_id = 12; - user_credential_type_t credential_type = 1; - user_credential_slot_t credential_slot = 1; + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + user_credential_slot_t invalid_credential_slot = 2; + auto credential_data = string_to_uint8_vector("1212"); auto valid_user_node = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); From 9a667344a5976dec3d51f6119ec02978ff8d9ac0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Fri, 6 Sep 2024 11:41:15 +0200 Subject: [PATCH 44/60] UIC-3222: Fix USER_SET error while reading user name Only check reported value instead of desired and reported Updated test to better coverage USER_SET --- .../zwave_command_class_user_credential.cpp | 2 +- ...ave_command_class_user_credential_test.cpp | 135 +++++++++++++----- 2 files changed, 100 insertions(+), 37 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index e010203e4..634a2330b 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -1260,7 +1260,7 @@ static sl_status_t zwave_command_class_user_credential_user_set( if (!is_delete_operation) { user_name_size = static_cast( user_unique_id_node.child_by_type(ATTRIBUTE(USER_NAME)) - .reported() + .get(DESIRED_OR_REPORTED_ATTRIBUTE) .size()); } diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 83587409b..7059f50f3 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1739,21 +1739,37 @@ void test_user_credential_user_add_modify_delete_happy_case() TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, status, - "User add should have returned SL_STATUS_OK"); + "zwave_command_class_user_credential_add_new_user " + "should have returned SL_STATUS_OK"); // Get user node - auto user_node - = attribute_store_get_first_child_by_type(endpoint_id_node, - ATTRIBUTE(USER_UNIQUE_ID)); + auto user_node = helper_test_and_get_node(ATTRIBUTE(USER_UNIQUE_ID)); + auto operation_type_node + = helper_test_and_get_node(ATTRIBUTE(USER_OPERATION_TYPE), user_node); + TEST_ASSERT_EQUAL_MESSAGE( + USER_SET_OPERATION_TYPE_ADD, + operation_type_node.desired(), + "Operation type mismatch for user add"); - TEST_ASSERT_TRUE_MESSAGE(attribute_store_node_exists(user_node), - "An user node should exist"); + zwave_frame set_frame; + set_frame.add( + static_cast(USER_SET_OPERATION_TYPE_ADD)); + set_frame.add(user_id); + set_frame.add(user_type); + set_frame.add(user_active_state); + set_frame.add(credential_rule); + set_frame.add(expiring_timeout); + set_frame.add(user_name_encoding); + set_frame.add(user_name); + helper_test_get_set_frame_happy_case(USER_SET, + operation_type_node, + set_frame); // Create notification report frame user_credential_modifier_type_t user_modifier_type = 2; user_credential_modifier_node_id_t user_modifier_node_id = 1212; - helper_simulate_user_report_frame(0x00, // user added - 0, // Next user id + helper_simulate_user_report_frame(USER_SET_OPERATION_TYPE_ADD, + 0, // Next user id user_modifier_type, user_modifier_node_id, user_id, @@ -1795,8 +1811,41 @@ void test_user_credential_user_add_modify_delete_happy_case() user_name_encoding = 2; user_name = "JACKIE CAMION TURBO PLUS"; - helper_simulate_user_report_frame(0x01, // modify user - 0, // Next user id + status = zwave_command_class_user_credential_modify_user(endpoint_id_node, + user_id, + user_type, + credential_rule, + user_active_state, + expiring_timeout, + user_name_encoding, + user_name.c_str()); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "zwave_command_class_user_credential_modify_user " + "should have returned SL_STATUS_OK"); + TEST_ASSERT_EQUAL_MESSAGE( + USER_SET_OPERATION_TYPE_MODIFY, + operation_type_node.desired(), + "Operation type mismatch for user modify"); + + // Set frame + set_frame.clear(); + set_frame.add(static_cast( + USER_SET_OPERATION_TYPE_MODIFY)); + set_frame.add(user_id); + set_frame.add(user_type); + set_frame.add(user_active_state); + set_frame.add(credential_rule); + set_frame.add(expiring_timeout); + set_frame.add(user_name_encoding); + set_frame.add(user_name); + helper_test_get_set_frame_happy_case(USER_SET, + operation_type_node, + set_frame); + + // Report back + helper_simulate_user_report_frame(USER_SET_OPERATION_TYPE_MODIFY, + 0, // Next user id user_modifier_type, user_modifier_node_id, user_id, @@ -1811,8 +1860,8 @@ void test_user_credential_user_add_modify_delete_happy_case() user_modifier_type = 5; user_modifier_node_id = 12122; - helper_simulate_user_report_frame(0x01, // modify user - 0, // Next user id + helper_simulate_user_report_frame(USER_SET_OPERATION_TYPE_MODIFY, + 0, // Next user id user_modifier_type, user_modifier_node_id, user_id, @@ -1833,8 +1882,22 @@ void test_user_credential_user_add_modify_delete_happy_case() status, "User delete should have returned SL_STATUS_OK"); - helper_simulate_user_report_frame(0x02, // modify user - 0, // Next user id + TEST_ASSERT_EQUAL_MESSAGE( + USER_SET_OPERATION_TYPE_DELETE, + operation_type_node.desired(), + "Operation type mismatch for user delete"); + + // Set frame + set_frame.clear(); + set_frame.add(static_cast( + USER_SET_OPERATION_TYPE_DELETE)); + set_frame.add(user_id); + helper_test_get_set_frame_happy_case(USER_SET, + operation_type_node, + set_frame); + + helper_simulate_user_report_frame(USER_SET_OPERATION_TYPE_DELETE, + 0, // Next user id user_modifier_type, user_modifier_node_id, user_id, @@ -2428,19 +2491,24 @@ void helper_test_credential_rejected_case(uint8_t report_type) REPORTED_ATTRIBUTE); auto invalid_cred_slot_node = valid_cred_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot, + invalid_credential_slot, DESIRED_ATTRIBUTE); + invalid_cred_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data, + DESIRED_ATTRIBUTE); - helper_simulate_credential_report_frame(report_type, // Duplicate credential - user_id, - credential_type, - credential_slot, - 1, - string_to_uint8_vector("1212"), - 0, - 2, - 0, - 0); + helper_simulate_credential_report_frame( + report_type, + user_id, + credential_type, + // Duplicate credential send the original slot + report_type == 0x07 ? credential_slot : invalid_credential_slot, + 1, + credential_data, + 0, + 2, + 0, + 0); // Here the Credential Report command should remove this not this report TEST_ASSERT_FALSE_MESSAGE(invalid_cred_slot_node.is_valid(), @@ -3259,7 +3327,6 @@ void test_user_credential_uuic_association_same_slot_different_user() destination_credential_slot, association_status); - // Test data structure TEST_ASSERT_TRUE_MESSAGE(source_nodes.credential_type_node.is_valid(), "Old credential type node should still exist"); @@ -3281,18 +3348,15 @@ void test_user_credential_uuic_association_same_slot_different_user() = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), credential_type, destination_user_id_node); - TEST_ASSERT_EQUAL_MESSAGE( - source_nodes.credential_slot_node.parent(), - destination_credential_type_node, - "Old credential slot node should have new parent"); + TEST_ASSERT_EQUAL_MESSAGE(source_nodes.credential_slot_node.parent(), + destination_credential_type_node, + "Old credential slot node should have new parent"); auto destination_credential_slot_node = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), destination_credential_slot, destination_credential_type_node); - - helper_test_credential_data(destination_credential_slot_node, credential_data, modifier_type); @@ -3397,10 +3461,9 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex credential_type, destination_user_id_node); - TEST_ASSERT_EQUAL_MESSAGE( - source_nodes.credential_slot_node.parent(), - destination_credential_type_node, - "Old credential slot node should have new parent"); + TEST_ASSERT_EQUAL_MESSAGE(source_nodes.credential_slot_node.parent(), + destination_credential_type_node, + "Old credential slot node should have new parent"); auto destination_credential_slot_node = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_SLOT), From 58e310e8aa7f4eaa770be1d79e8aad03773a39dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Fri, 6 Sep 2024 12:07:51 +0200 Subject: [PATCH 45/60] UIC-3222: Better handling of rejection of credential due to security rules Works both when adding a credential and modifying it --- .../zwave_command_class_user_credential.cpp | 46 +++++++++++++----- ...ave_command_class_user_credential_test.cpp | 47 ++++++++++++++++++- 2 files changed, 81 insertions(+), 12 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 634a2330b..249036c89 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -601,17 +601,41 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( // Helper function to clean up pending credentials slot nodes auto clean_up_pending_credentials_slot_nodes = [&]() { - auto nodes = get_credential_identifier_nodes( - endpoint_node, - {user_id, REPORTED_ATTRIBUTE}, - {credential_type, DESIRED_OR_REPORTED_ATTRIBUTE}, - {credential_slot, DESIRED_ATTRIBUTE}); - - nodes.slot_node.delete_node(); - sl_log_debug(LOG_TAG, "Cleaning temporary credential slot node : %d (credential type %d, user %d)", - credential_slot, - credential_type, - user_id); + try { + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, DESIRED_OR_REPORTED_ATTRIBUTE}, + {credential_slot, DESIRED_ATTRIBUTE}); + + nodes.slot_node.delete_node(); + sl_log_debug(LOG_TAG, + "Cleaning temporary credential slot node : %d (credential " + "type %d, user %d)", + credential_slot, + credential_type, + user_id); + } catch (const std::exception &e) { + // Try again with reported attribute + // That should not trigger an error, but if it does it means that something went wrong + auto nodes = get_credential_identifier_nodes( + endpoint_node, + {user_id, REPORTED_ATTRIBUTE}, + {credential_type, DESIRED_OR_REPORTED_ATTRIBUTE}, + {credential_slot, REPORTED_ATTRIBUTE}); + + sl_log_debug( + LOG_TAG, + "Cleaning desired values of credential slot node : %d (credential " + "type %d, user %d)", + credential_slot, + credential_type, + user_id); + + for (auto child: nodes.slot_node.children()) { + child.clear_desired(); + } + } }; // We should have a valid user id if we receive this report diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 7059f50f3..d5bc653d5 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2550,11 +2550,56 @@ void test_user_credential_credential_set_error_report_cred_duplicate_happy_case( helper_test_credential_rejected_case(0x07); } -void test_user_credential_credential_set_error_report_cred_security_rule_happy_case() +void test_user_credential_credential_set_error_report_cred_security_rule_add_happy_case() { helper_test_credential_rejected_case(0x08); } +void test_user_credential_credential_set_error_report_cred_security_rule_modify_happy_case() +{ + user_credential_user_unique_id_t user_id = 12; + user_credential_type_t credential_type = 1; + user_credential_slot_t credential_slot = 1; + uint8_t crb = 1; + auto credential_data = string_to_uint8_vector("1212"); + + auto valid_user_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + auto valid_cred_type_node + = valid_user_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), credential_type); + auto valid_cred_slot_node + = valid_cred_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + REPORTED_ATTRIBUTE); + + auto crb_node + = valid_cred_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_READ_BACK), + crb, + DESIRED_ATTRIBUTE); + auto credential_data_node + = valid_cred_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_DATA), + credential_data, + DESIRED_ATTRIBUTE); + + helper_simulate_credential_report_frame(0x08, + user_id, + credential_type, + credential_slot, + crb, + credential_data, + 0, + 2, + 0, + 0); + + // Check if the rejected report has cleared all desired values + TEST_ASSERT_FALSE_MESSAGE(crb_node.desired_exists(), + "CRB desired value should NOT exist"); + + TEST_ASSERT_FALSE_MESSAGE(credential_data_node.desired_exists(), + "Credential data desired value should NOT exist"); +} + void test_user_credential_remove_all_users_happy_case() { helper_set_version(1); From d4c07f1715415efc682579b8169e86e3b279bb9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 9 Sep 2024 16:49:51 +0200 Subject: [PATCH 46/60] UIC-3222: Add MQTT notification when slot has changed Use a new callback mechanism that allows the server to listen to certain event --- .../src/user_credential_cluster_server.cpp | 117 ++++++++++++++---- ...wave_command_class_user_credential_types.h | 7 ++ .../zwave_command_class_user_credential.cpp | 68 +++++----- .../src/zwave_command_class_user_credential.h | 12 ++ .../zwave_command_class_user_credential_api.h | 1 - 5 files changed, 154 insertions(+), 51 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 95122b37b..0f9ca03ad 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -13,6 +13,7 @@ #include "user_credential_cluster_server.h" #include "zcl_cluster_servers_helpers.hpp" // Interfaces +#include "zwave_command_class_user_credential.h" #include "zwave_command_class_user_credential_api.h" // ZPC includes @@ -105,16 +106,16 @@ static const user_attributes_mqtt_map_t credential_attributes {ATTRIBUTE(ASSOCIATION_STATUS), {"AssociationStatus"}}, {ATTRIBUTE(CREDENTIAL_LEARN_STATUS), {"CredentialLearnStatus"}}}; -static const user_attributes_mqtt_map_t credential_rules_attributes - = {{ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), {"LearnSupport", convert_to_bool}}, - {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), {"SupportedSlotCount"}}, - {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), {"CredentialMinLength"}}, - {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), {"CredentialMaxLength"}}, - {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), - {"LearnRecommendedTimeout"}}, - {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), {"LearnNumberOfSteps"}}, - {ATTRIBUTE(CREDENTIAL_CHECKSUM), {"CredentialChecksum"}}, - {ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), {"CredentialChecksumError"}}}; +static const user_attributes_mqtt_map_t credential_rules_attributes = { + {ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT), {"LearnSupport", convert_to_bool}}, + {ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT), {"SupportedSlotCount"}}, + {ATTRIBUTE(CREDENTIAL_MIN_LENGTH), {"CredentialMinLength"}}, + {ATTRIBUTE(CREDENTIAL_MAX_LENGTH), {"CredentialMaxLength"}}, + {ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT), + {"LearnRecommendedTimeout"}}, + {ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS), {"LearnNumberOfSteps"}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM), {"CredentialChecksum"}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), {"CredentialChecksumError"}}}; /////////////////////////////////////////////////////////////////////////////// // DotDot MQTT incoming commands handling functions @@ -564,17 +565,17 @@ sl_status_t get_user_checksum(dotdot_unid_t unid, return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK : SL_STATUS_FAIL; - } return zwave_command_class_user_credential_get_user_checksum(endpoint_node, user_uniqueid); } -sl_status_t get_credential_checksum(dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type, - CredType credential_type) +sl_status_t + get_credential_checksum(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + CredType credential_type) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -588,7 +589,6 @@ sl_status_t get_credential_checksum(dotdot_unid_t unid, return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK : SL_STATUS_FAIL; - } return zwave_command_class_user_credential_get_credential_checksum( @@ -651,6 +651,18 @@ std::string get_base_mqtt_topic(attribute_store::attribute updated_node_cpp) return (mqtt_topic % unid % static_cast(endpoint_id)).str(); } +/** + * @brief Get the base MQTT topic for a user. + * + * @see get_base_user_mqtt_topic(attribute_store::attribute) + */ +std::string + get_base_user_mqtt_topic_str(const std::string &base_mqtt_topic, + user_credential_user_unique_id_t user_id) +{ + return (boost::format("%1%/User/%2%") % base_mqtt_topic % user_id).str(); +} + /** * @brief Get the base MQTT topic for a user. * @@ -676,7 +688,7 @@ std::string = updated_node_cpp.first_parent_or_self(ATTRIBUTE(USER_UNIQUE_ID)) .reported(); - return (mqtt_topic % base_mqtt_topic % user_id).str(); + return get_base_user_mqtt_topic_str(base_mqtt_topic, user_id); } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while publishing User attribute (%s) : %s", @@ -687,6 +699,23 @@ std::string return ""; } +/** + * @brief Get the base MQTT topic for a credential. + * + * @see get_base_credential_mqtt_topic(attribute_store::attribute updated_node_cpp) + */ +std::string + get_base_credential_mqtt_topic_str(const std::string &base_user_mqtt_topic, + user_credential_slot_t credential_slot, + user_credential_type_t credential_type) +{ + std::string credential_type_str + = cred_type_get_enum_value_name(credential_type); + return (boost::format("%1%/Credential/%2%/%3%") % base_user_mqtt_topic + % credential_type_str % credential_slot) + .str(); +} + /** * @brief Get the base MQTT topic for a credential. * @@ -713,12 +742,10 @@ std::string user_credential_type_t credential_type = updated_node_cpp.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)) .reported(); - std::string credential_type_str - = cred_type_get_enum_value_name(credential_type); - return (boost::format("%1%/Credential/%2%/%3%") % base_user_mqtt_topic - % credential_type_str % credential_slot) - .str(); + return get_base_credential_mqtt_topic_str(base_user_mqtt_topic, + credential_slot, + credential_type); } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while publishing Credential attribute (%s) : %s", @@ -973,6 +1000,48 @@ void on_credential_update(attribute_store_node_t updated_node, credential_attributes); } +/** + * @brief Callback for when a UUIC slot is updated. + * + * This is used to update the MQTT topics when a slot is updated. + * Since we only monitor properties of the slot, we need to update the slot + * itself when it changes. + * + * This callback is called whenever a slot is updated thanks to the UUIC command. + * + * @param old_credential_slot The old credential slot id. + * @param node The node that contains the updated slot. + */ +void on_uuic_slot_update( + const user_credential_credential_identifier_t old_credential_slot, + attribute_store_node_t node) +{ + auto credential_slot_node = attribute_store::attribute(node); + + // Update old slot + auto old_user_topic + = get_base_user_mqtt_topic_str(get_base_mqtt_topic(credential_slot_node), + old_credential_slot.user_unique_id); + auto old_credential_topic + = get_base_credential_mqtt_topic_str(old_user_topic, + old_credential_slot.credential_slot, + old_credential_slot.credential_type); + // Simulate deletion of the old slot + // First simulate deletion of all attributes + for (auto [attribute_store_type, mqtt_data]: credential_attributes) { + std::string mqtt_topic + = mqtt_topic_add_attribute(old_credential_topic, mqtt_data.topic); + uic_mqtt_publish(mqtt_topic.c_str(), "", 0, true); + } + // Then delete the slot itself + uic_mqtt_publish(old_credential_topic.c_str(), "", 0, true); + + // Trigger update for the new slot + for (auto child: credential_slot_node.children()) { + on_credential_update(child, ATTRIBUTE_UPDATED); + } +} + /////////////////////////////////////////////////////////////////////////////// // Init and teardown functions. ////////////////////////////////////////////////////////////////////////////// @@ -986,6 +1055,10 @@ sl_status_t user_credential_cluster_server_init() register_attributes_to_mqtt_map(credential_rules_attributes, &on_credential_rules_update); + // Custom callbacks + zwave_command_class_user_credential_set_uuic_slot_changed_callback( + &on_uuic_slot_update); + // Command callbacks // User uic_mqtt_dotdot_user_credential_add_user_callback_set(&add_user_command); diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index 218c17207..d9c9e77b9 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -81,6 +81,13 @@ typedef uint8_t user_credential_learn_timeout_t; ///> Credential Learn Status. uint8_t typedef uint8_t user_credential_learn_status_t; +///> Full identifier for a user credential. +typedef struct user_credential_credential_identifier { + user_credential_user_unique_id_t user_unique_id; + user_credential_type_t credential_type; + user_credential_slot_t credential_slot; +} user_credential_credential_identifier_t; + #ifdef __cplusplus extern "C" { #endif diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 249036c89..470320d5c 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -41,6 +41,7 @@ #include #include #include +#include // Cpp Attribute store #include "attribute.hpp" @@ -71,8 +72,23 @@ using namespace user_credential_helpers; namespace { zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); + +// Callbacks +std::set user_credential_slot_changed_callback; } +///////////////////////////////////////////////////////////////////////////// +// Callbacks +///////////////////////////////////////////////////////////////////////////// +void zwave_command_class_user_credential_set_uuic_slot_changed_callback( + user_credential_slot_changed_callback_t callback) +{ + if (callback != nullptr) { + user_credential_slot_changed_callback.insert(callback); + } +} + + ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -1160,17 +1176,12 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( const uint8_t association_status = parser.read_byte(); sl_log_debug(LOG_TAG, - "User Unique Identifier Credential Association Report. Source " - "User ID: %d / " - "Source Credential Type: %d / Source Credential Slot: %d / " - "Destination User ID: %d / Destination Credential Slot: %d", - "Association status : %d", - source_user_id, - source_credential_type, - source_credential_slot, - destination_user_id, - destination_credential_slot, - association_status); + "User Unique Identifier Credential Association Report."); + sl_log_debug(LOG_TAG,"\tSource User ID: %d", source_user_id); + sl_log_debug(LOG_TAG,"\tSource Credential Type: %d", source_credential_type); + sl_log_debug(LOG_TAG,"\tSource Credential Slot: %d", source_credential_slot); + sl_log_debug(LOG_TAG,"\tDestination User ID: %d", destination_user_id); + sl_log_debug(LOG_TAG,"\tDestination Credential Slot: %d", destination_credential_slot); // Get nodes auto source_credential_nodes = get_credential_identifier_nodes( @@ -1202,22 +1213,17 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( return SL_STATUS_OK; } - // Simple case : we only have to change the slot number - if (destination_user_id == source_user_id) { - sl_log_info(LOG_TAG, - "Moving slot %d to slot %d (user %d)", - source_credential_slot, - destination_credential_slot, - destination_user_id); - source_credential_slot_node.set_reported(destination_credential_slot); - } else { - // Complex case : we have to move the slot to another user - sl_log_info(LOG_TAG, - "Moving slot %d (user %d) to slot %d (user %d)", - source_credential_slot, - source_user_id, - destination_credential_slot, - destination_user_id); + sl_log_info(LOG_TAG, + "Moving slot %d (user %d) to slot %d (user %d)", + source_credential_slot, + source_user_id, + destination_credential_slot, + destination_user_id); + source_credential_slot_node.set_reported(destination_credential_slot); + + // Need to move to new user + if (destination_user_id != source_user_id) { + sl_log_debug(LOG_TAG, "Moving slot to new user"); // Get destination user node auto destination_user_id_node @@ -1242,8 +1248,14 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( destination_user_id); return result; } + } - source_credential_slot_node.set_reported(destination_credential_slot); + // Call MQTT callback if needed to notify that the slot has changed + for (auto &uicc_slot_changed_callback: + user_credential_slot_changed_callback) { + uicc_slot_changed_callback( + {source_user_id, source_credential_type, source_credential_slot}, + source_credential_slot_node); } } catch (const std::exception &e) { sl_log_error(LOG_TAG, diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 098bf776c..658207339 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -32,11 +32,23 @@ extern "C" { #endif + +typedef void (*user_credential_slot_changed_callback_t)( + const user_credential_credential_identifier_t old_credential_slot_id, + const attribute_store_node_t new_credential_node); + +void zwave_command_class_user_credential_set_uuic_slot_changed_callback( + user_credential_slot_changed_callback_t callback); + + sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus } #endif + + + #endif //ZWAVE_COMMAND_CLASS_USER_CREDENTIAL_H /** @} end zwave_command_class_user_credential */ \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h index 90a0c39df..fc2401091 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h @@ -344,7 +344,6 @@ sl_status_t zwave_command_class_user_credential_get_credential_checksum( attribute_store_node_t endpoint_node, user_credential_type_t credential_type); - #ifdef __cplusplus } #endif From aad5a3fa33fbc711fe230ff6efb69a3dc185c7ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 10 Sep 2024 15:41:49 +0200 Subject: [PATCH 47/60] UIC-3222: Indicate status of UUIC association to DevUI --- .../src/user_credential_cluster_server.cpp | 13 +++++ .../zwave_command_class_user_credential.cpp | 58 +++++++++++++------ .../src/zwave_command_class_user_credential.h | 8 ++- 3 files changed, 61 insertions(+), 18 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 0f9ca03ad..1e6419d80 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -1042,6 +1042,17 @@ void on_uuic_slot_update( } } +void on_user_credential_message(sl_log_level_t log_level, + const std::string message) +{ + nlohmann::json payload; + payload["level"] = log_level; + payload["message"] = message; + + std::string payload_str = payload.dump(); + uic_mqtt_publish("ucl/Event", payload_str.c_str(), payload_str.length(), true); +} + /////////////////////////////////////////////////////////////////////////////// // Init and teardown functions. ////////////////////////////////////////////////////////////////////////////// @@ -1058,6 +1069,8 @@ sl_status_t user_credential_cluster_server_init() // Custom callbacks zwave_command_class_user_credential_set_uuic_slot_changed_callback( &on_uuic_slot_update); + zwave_command_class_user_credential_set_message_callback( + &on_user_credential_message); // Command callbacks // User diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 470320d5c..96e6a76b4 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -75,8 +75,10 @@ zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); // Callbacks std::set user_credential_slot_changed_callback; +std::set user_credential_slot_message_callback; } + ///////////////////////////////////////////////////////////////////////////// // Callbacks ///////////////////////////////////////////////////////////////////////////// @@ -88,6 +90,26 @@ void zwave_command_class_user_credential_set_uuic_slot_changed_callback( } } +void zwave_command_class_user_credential_set_message_callback( + user_credential_slot_message_callback_t callback) +{ + if (callback != nullptr) { + user_credential_slot_message_callback.insert(callback); + } +} + +void send_message_to_mqtt(sl_log_level level, const std::string &message) +{ + if (level == SL_LOG_DEBUG) { + sl_log_critical(LOG_TAG, "Debug message should not be sent to MQTT"); + return; + } + sl_log(LOG_TAG, level, "%s", message.c_str()); + + for (auto &callback: user_credential_slot_message_callback) { + callback(level, message); + } +} ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation @@ -1206,19 +1228,21 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // If something went wrong end device side, log the error and return // This should handle the slot already taken case if (association_status != USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS) { - sl_log_error(LOG_TAG, - "User Unique Identifier Credential Association error. " - "Reported status code : %d", - association_status); + send_message_to_mqtt(SL_LOG_ERROR, + "User Unique Identifier Credential Association error. " + "Reported status code : " + std::to_string(association_status)); return SL_STATUS_OK; } - sl_log_info(LOG_TAG, - "Moving slot %d (user %d) to slot %d (user %d)", - source_credential_slot, - source_user_id, - destination_credential_slot, - destination_user_id); + send_message_to_mqtt( + SL_LOG_INFO, + (boost::format("Credential Slot %1% for type %2% (user %3%) moved to " + "Credential slot %4% (user %5%)") + % source_credential_slot + % static_cast(source_credential_type) % source_user_id + % destination_credential_slot % destination_user_id) + .str()); + source_credential_slot_node.set_reported(destination_credential_slot); // Need to move to new user @@ -1239,13 +1263,13 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( sl_status_t result = source_credential_slot_node.change_parent( destination_credential_type_node); if (result != SL_STATUS_OK) { - sl_log_error( - LOG_TAG, - "Error while moving slot %d (user %d) to slot %d (user %d)", - source_credential_slot, - source_user_id, - destination_credential_slot, - destination_user_id); + send_message_to_mqtt( + SL_LOG_ERROR, + (boost::format( + "Error while moving slot %1% (user %2%) to slot %3% (user %4%)") + % source_credential_slot % source_user_id + % destination_credential_slot % destination_user_id) + .str()); return result; } } diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 658207339..8f6d9d63a 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -29,6 +29,8 @@ #include "attribute_store.h" #ifdef __cplusplus +#include +#include "sl_log.h" extern "C" { #endif @@ -44,7 +46,11 @@ void zwave_command_class_user_credential_set_uuic_slot_changed_callback( sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus -} +} // extern "C" +typedef void (*user_credential_slot_message_callback_t)( + sl_log_level level, const std::string message); +void zwave_command_class_user_credential_set_message_callback( + user_credential_slot_message_callback_t callback); #endif From 295475b605e78eaf852840af64c8b4d84b70188e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 11 Sep 2024 11:12:43 +0200 Subject: [PATCH 48/60] UIC-3222: Update Get Checksum function Add a notification to the UI Set the received checksum last --- .../zwave_command_class_user_credential.cpp | 27 ++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 96e6a76b4..88b226c22 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -35,6 +35,7 @@ // DotDot #include "unify_dotdot_attribute_store_node_state.h" +#include "dotdot_mqtt_helpers.hpp" // Cpp related #include @@ -1734,9 +1735,6 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( auto user_node = get_user_unique_id_node(endpoint_node, user_id, REPORTED_ATTRIBUTE); - user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) - .set_reported(user_checksum); - // Compute checksum ourselves to see if it matches user_credential::checksum_calculator checksum_calculator; @@ -1778,6 +1776,19 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), checksum_calculator.compute_checksum(), user_checksum); + + user_node.emplace_node(ATTRIBUTE(USER_CHECKSUM)) + .set_reported(user_checksum); + + if (result == SL_STATUS_OK) { + send_message_to_mqtt(SL_LOG_INFO, + "User Checksum for user " + std::to_string(user_id) + + " is correct."); + } else { + send_message_to_mqtt(SL_LOG_ERROR, + "Mismatch User Checksum for user " + + std::to_string(user_id)); + } } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while parsing User Checksum Report frame : %s", @@ -1899,6 +1910,16 @@ sl_status_t ATTRIBUTE(CREDENTIAL_CHECKSUM_MISMATCH_ERROR), checksum_calculator.compute_checksum(), credential_checksum); + + if (result == SL_STATUS_OK) { + send_message_to_mqtt(SL_LOG_INFO, + "Credential Checksum for " + cred_type_get_enum_value_name(credential_type) + + " is correct."); + } else { + send_message_to_mqtt(SL_LOG_ERROR, + "Mismatch Credential Checksum for " + + cred_type_get_enum_value_name(credential_type)); + } } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while parsing Credential Checksum Report frame : %s", From a52bb3b1b4e77361b4a7b11b13e867b5e7ba07e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 11 Sep 2024 11:50:09 +0200 Subject: [PATCH 49/60] UIC-3222: Credential Learn fix Allow to add an credential that is already in the node tree Check desired or reported value of CREDENTIAL_LEARN_OPERATION_TYPE to avoid issues with supervision Send status to mqtt --- .../zwave_command_class_user_credential.cpp | 59 ++++++++----------- 1 file changed, 26 insertions(+), 33 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 88b226c22..8257a41a8 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -686,26 +686,17 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( switch (credential_report_type) { case credential_report_type_t::CREDENTIAL_ADDED: - if (!is_credential_available(endpoint_node, - credential_type, - credential_slot)) { - sl_log_error(LOG_TAG, - "Credential already exists. Can't add credential Type " - "%d, Slot %d (User %d)", - credential_type, - credential_slot, - user_id); - return SL_STATUS_FAIL; - } else { - credential_type_node - = create_or_update_desired_value(user_id_node, - ATTRIBUTE(CREDENTIAL_TYPE), - credential_type); - credential_slot_node - = create_or_update_desired_value(credential_type_node, - ATTRIBUTE(CREDENTIAL_SLOT), - credential_slot); - } + // In case of credential learn, the credential is already present in the + // node tree. So we don't check if the node exists before creating it. + // Only update existing nodes if they are present. + credential_type_node + = create_or_update_desired_value(user_id_node, + ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + credential_slot_node + = create_or_update_desired_value(credential_type_node, + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); break; case credential_report_type_t::CREDENTIAL_MODIFIED: { // Should throw an exception if the credential doesn't exists @@ -1030,9 +1021,9 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( const uint8_t step_remaining = parser.read_byte(); sl_log_debug(LOG_TAG, - "Credential Learn Status Report. Credential Type: %d / " + "Credential Learn Status Report. Credential Type: %s / " "Credential Slot: %d (User %d)", - credential_type, + cred_type_get_enum_value_name(credential_type).c_str(), credential_slot, user_id); @@ -1043,10 +1034,12 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( {credential_slot, DESIRED_OR_REPORTED_ATTRIBUTE}); // Get operation type so we can handle error cases + // We use desired or reported here since it can be set to reported by the + // supervision process. auto operation_type = credential_id_nodes.slot_node .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE)) - .desired(); + .desired_or_reported(); // Action based of current learn status std::string learn_status_str; @@ -1065,11 +1058,12 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( learn_status_str = "Credential Learn already in progress"; break; case CREDENTIAL_LEARN_REPORT_ENDED_NOT_DUE_TO_TIMEOUT: - learn_status_str = "Credential Learn ended not due to timeout"; + log_level = SL_LOG_ERROR; + learn_status_str = "Credential Learn Ended (not due to timeout)"; need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); break; case CREDENTIAL_LEARN_REPORT_TIMEOUT: - log_level = SL_LOG_WARNING; + log_level = SL_LOG_ERROR; learn_status_str = "Credential Learn Timeout"; need_deletion = (operation_type == USER_CREDENTIAL_OPERATION_TYPE_ADD); break; @@ -1092,17 +1086,16 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( log_level = SL_LOG_CRITICAL; } - sl_log(LOG_TAG, - log_level, - "%s for User %d, Credential Type %d, " - "Credential Slot %d", - learn_status_str.c_str(), - user_id, - credential_type, - credential_slot); + auto message = boost::format("Credential Learn Status Report : %1% for " + "Credential Type %2% (Slot %3%, User %4%)") + % learn_status_str + % cred_type_get_enum_value_name(credential_type) + % credential_slot % user_id; + send_message_to_mqtt(log_level, message.str()); if (need_deletion) { credential_id_nodes.slot_node.delete_node(); + return SL_STATUS_OK; } // Update nodes From df3218747246bbcadcc587a69c2b292a9bbc6727 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 11 Sep 2024 14:04:36 +0200 Subject: [PATCH 50/60] UIC-3222: Display Credential type name when possible in logs --- .../zwave_command_class_user_credential.cpp | 86 +++++++++++-------- 1 file changed, 48 insertions(+), 38 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 8257a41a8..731ac579a 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -79,7 +79,6 @@ std::set user_credential_slot_changed_c std::set user_credential_slot_message_callback; } - ///////////////////////////////////////////////////////////////////////////// // Callbacks ///////////////////////////////////////////////////////////////////////////// @@ -112,6 +111,17 @@ void send_message_to_mqtt(sl_log_level level, const std::string &message) } } +///////////////////////////////////////////////////////////////////////////// +// Helpers +///////////////////////////////////////////////////////////////////////////// +std::string get_credential_type_debug_str(user_credential_type_t credential_type) { + auto fmt = boost::format("Credential Type %1% (%2%)") + % cred_type_get_enum_value_name(credential_type) + % static_cast(credential_type); + + return fmt.str(); +} + ///////////////////////////////////////////////////////////////////////////// // Version & Attribute Creation ///////////////////////////////////////////////////////////////////////////// @@ -415,9 +425,9 @@ void trigger_get_credential(attribute_store::attribute &user_unique_id_node, { sl_log_debug(LOG_TAG, "Trigger GET credential for user %d : " - "Credential type %d, credential slot %d", + "Credential type %s, credential slot %d", user_unique_id_node.reported(), - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); user_unique_id_node .emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), @@ -547,8 +557,8 @@ sl_status_t { if (user_id != 0 && credential_type != 0 && credential_slot != 0) { sl_log_info(LOG_TAG, - "Credential Deleted. Type %d, Slot %d (User %d)", - credential_type, + "Credential Deleted. Type %s, Slot %d (User %d)", + get_credential_type_debug_str(credential_type).c_str(), credential_slot, user_id); // Delete the credential slot node @@ -559,8 +569,8 @@ sl_status_t .slot_node.delete_node(); } else if (user_id != 0 && credential_type != 0 && credential_slot == 0) { sl_log_info(LOG_TAG, - "All credential type %d deleted for user %d.", - credential_type, + "All credential type %s deleted for user %d.", + get_credential_type_debug_str(credential_type).c_str(), user_id); for_each_credential_type_nodes_for_user( user_id_node, @@ -584,8 +594,8 @@ sl_status_t }); } else if (user_id == 0 && credential_type != 0 && credential_slot == 0) { sl_log_info(LOG_TAG, - "All credentials of type %d are deleted", - credential_type); + "All credentials of type %s are deleted", + get_credential_type_debug_str(credential_type).c_str()); for_each_credential_type_nodes( endpoint_node, [&](attribute_store::attribute &credential_type_node) { @@ -594,10 +604,10 @@ sl_status_t credential_type); } else { sl_log_critical(LOG_TAG, - "Invalid combination of user_id %d, credential_type %d and " + "Invalid combination of user_id %d, credential_type %s and " "credential_slot %d for credential deletion", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); return SL_STATUS_FAIL; } @@ -632,9 +642,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( auto credential_slot = parser.read_sequential(2); sl_log_debug(LOG_TAG, - "Credential Report (%d). Type %d, Slot %d (User %d)", + "Credential Report (%d). %s, Slot %d (User %d)", credential_report_type, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot, user_id); @@ -650,9 +660,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( nodes.slot_node.delete_node(); sl_log_debug(LOG_TAG, "Cleaning temporary credential slot node : %d (credential " - "type %d, user %d)", + "type %s, user %d)", credential_slot, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), user_id); } catch (const std::exception &e) { // Try again with reported attribute @@ -666,9 +676,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( sl_log_debug( LOG_TAG, "Cleaning desired values of credential slot node : %d (credential " - "type %d, user %d)", + "type %s, user %d)", credential_slot, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), user_id); for (auto child: nodes.slot_node.children()) { @@ -718,11 +728,11 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( credential_type, credential_slot); case credential_report_type_t::CREDENTIAL_UNCHANGED: - sl_log_info(LOG_TAG, - "Credential Unchanged. Type %d, Slot %d (User %d)", - credential_type, - credential_slot, - user_id); + send_message_to_mqtt(SL_LOG_INFO, + "Credential Unchanged. Type " + + get_credential_type_debug_str(credential_type) + + ", Slot " + std::to_string(credential_slot) + + " (User " + std::to_string(user_id) + ")"); return SL_STATUS_OK; // Update desired value if found, otherwise create the nodes case credential_report_type_t::RESPONSE_TO_GET: @@ -767,9 +777,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( case credential_report_type_t::CREDENTIAL_ADD_REJECTED_LOCATION_OCCUPIED: sl_log_error(LOG_TAG, "Credential data rejected as it already exists : user %d, " - "credential type %d, credential slot %d", + "credential type %s, credential slot %d", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); clean_up_pending_credentials_slot_nodes(); return SL_STATUS_OK; @@ -777,9 +787,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( sl_log_error( LOG_TAG, "Credential data cannot be modified as it does not exists : user %d, " - "credential type %d, credential slot %d", + "credential type %s, credential slot %d", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); credential_type_node @@ -790,9 +800,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( if (!credential_type_node.is_valid()) { sl_log_debug( LOG_TAG, - "No credential type found for user %d, credential type %d", + "No credential type found for user %d, credential type %s", user_id, - credential_type); + get_credential_type_debug_str(credential_type).c_str()); return SL_STATUS_OK; } @@ -808,10 +818,10 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( // Do nothing, the credential GET will clean up for us sl_log_warning(LOG_TAG, "Duplicate Credential (Already present for user %d, " - "credential type %d, " + "credential type %s, " "credential slot %d)", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); // So this is the fun part when we hunt down the faulty credential slot node @@ -859,10 +869,10 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( sl_log_warning( LOG_TAG, "Credential data rejected as it doesn't respect manufacturer " - "security rules : user %d, credential type %d, " + "security rules : user %d, credential type %s, " "credential slot %d", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); // This should contains the faulty credential clean_up_pending_credentials_slot_nodes(); @@ -871,9 +881,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( sl_log_warning( LOG_TAG, "Credential data rejected as location is already assigned : user %d, " - "credential type %d, credential slot %d", + "credential type %s, credential slot %d", user_id, - credential_type, + get_credential_type_debug_str(credential_type).c_str(), credential_slot); // This should contains the faulty credential clean_up_pending_credentials_slot_nodes(); @@ -1230,10 +1240,10 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( send_message_to_mqtt( SL_LOG_INFO, - (boost::format("Credential Slot %1% for type %2% (user %3%) moved to " + (boost::format("Credential Slot %1% (%2%) (user %3%) moved to " "Credential slot %4% (user %5%)") % source_credential_slot - % static_cast(source_credential_type) % source_user_id + % cred_rule_get_enum_value_name(source_credential_type) % source_user_id % destination_credential_slot % destination_user_id) .str()); @@ -1868,9 +1878,9 @@ sl_status_t credential_type); if (!credential_type_node.is_valid()) { sl_log_error(LOG_TAG, - "Can't find Credential Type %d reported by Credential " + "Can't find Credential Type %s reported by Credential " "Checksum Report", - credential_type); + get_credential_type_debug_str(credential_type).c_str()); return SL_STATUS_FAIL; } From d2fadefd53144c0fee544e64693f986f5c7db046 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 12 Sep 2024 11:07:26 +0200 Subject: [PATCH 51/60] UIC-3222: Refactor Get All Users Checksum Now the attribute ALL_USERS_CHECKSUM is defined at the end of the User interview if device support it Add command to force the refresh of the checksum --- .../src/user_credential_cluster_server.cpp | 24 ++- .../user_credential_cluster_server_test.cpp | 77 +++++++ .../user_credential_user_capabilities.cpp | 8 +- .../user_credential_user_capabilities.h | 9 +- .../zwave_command_class_user_credential.cpp | 143 ++++++++----- ...wave_command_class_user_credential_api.cpp | 45 +++- .../zwave_command_class_user_credential_api.h | 27 +++ ...ave_command_class_user_credential_test.cpp | 199 ++++++++++++++---- 8 files changed, 442 insertions(+), 90 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 1e6419d80..36c02ecdd 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -548,6 +548,25 @@ sl_status_t uuic_association_set(dotdot_unid_t unid, destination_credential_slot); } +sl_status_t get_all_users_checksum(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + return zwave_command_class_user_credential_supports(endpoint_node, + ALL_USERS_CHECKSUM_GET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_get_all_users_checksum(endpoint_node); +} + sl_status_t get_user_checksum(dotdot_unid_t unid, dotdot_endpoint_id_t endpoint, uic_mqtt_dotdot_callback_call_type_t call_type, @@ -1048,7 +1067,7 @@ void on_user_credential_message(sl_log_level_t log_level, nlohmann::json payload; payload["level"] = log_level; payload["message"] = message; - + std::string payload_str = payload.dump(); uic_mqtt_publish("ucl/Event", payload_str.c_str(), payload_str.length(), true); } @@ -1113,5 +1132,8 @@ sl_status_t user_credential_cluster_server_init() // Credential Checksum uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set( &get_credential_checksum); + // All Users Checksum + uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set( + &get_all_users_checksum); return SL_STATUS_OK; } diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index bc316c16d..c5262d701 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -26,6 +26,7 @@ extern "C" { #include "attribute_store_defined_attribute_types.h" #include "zwave_command_class_association_types.h" #include "zap-types.h" +#include "zwave_command_class_version_types.h" // ZPC Components #include "zpc_attribute_store_type_registration.h" @@ -48,6 +49,9 @@ extern "C" { // Attribute macro, shortening those long defines for attribute types: #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type +// Useful definitions +attribute_store::attribute cpp_endpoint_node; + // Header declarations void mock_deletion_user_mqtt_topic(user_credential_user_unique_id_t user_id); void mock_deletion_cred_mqtt_topic(user_credential_user_unique_id_t user_id, @@ -86,6 +90,7 @@ uic_mqtt_dotdot_user_credential_credential_learn_stop_callback_t credential_lear uic_mqtt_dotdot_user_credential_credential_association_callback_t credential_association_command = NULL; uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_user_checksum_command = NULL; uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t get_credential_checksum_command = NULL; +uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t get_all_users_checksum_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -210,6 +215,15 @@ void uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub( get_credential_checksum_command = callback; } +void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub( + const uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t + callback, + int cmock_num_calls) +{ + get_all_users_checksum_command = callback; +} + + /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() { @@ -293,6 +307,7 @@ void setUp() uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_user_checksum_callback_set_stub); // Credential checksum uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub); + uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub); // clang-format on // Run the component init @@ -303,6 +318,17 @@ void setUp() setup_user_capabilities(); // Need to call this after init() to have the mqtt callback initialized setup_cred_capabilities(); + + // Setup helper + cpp_endpoint_node = attribute_store::attribute(endpoint_id_node); +} + +void set_version(zwave_cc_version_t version) +{ + // Set the version + cpp_endpoint_node + .emplace_node(ATTRIBUTE(VERSION)) + .set_reported(version); } ///////////////////////////////////////////////////////////////////////// @@ -2352,6 +2378,57 @@ void test_user_credential_cluster_test_credential_checksum_happy_case() "Checksum node reported value should be not defined"); } + +void test_user_credential_cluster_test_all_users_checksum_happy_case() +{ + set_version(1); + + // Command not supported yet (default user capabilities SUPPORT_ALL_USERS_CHECKSUM set to 0) + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + get_all_users_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK), + "Not supported yet since we are missing the capability"); + + cpp_endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM)) + .set_reported(1); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_all_users_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + "Should be able to setup attribute store for get_all_users_checksum"); + + auto checksum_node + = cpp_endpoint_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)); + + TEST_ASSERT_TRUE_MESSAGE( + checksum_node.is_valid(), + "All users checksum node should exists"); + + checksum_node.set_desired(1312); + checksum_node.set_reported(12); + + // Try a second time to see if we clear the attributes + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + get_all_users_checksum_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL), + "Should be able to setup attribute store for get_all_users_checksum"); + + TEST_ASSERT_FALSE_MESSAGE( + checksum_node.desired_exists(), + "Checksum node desired value should NOT exists"); + + TEST_ASSERT_FALSE_MESSAGE( + checksum_node.reported_exists(), + "Checksum node reported value should NOT exists"); +} + + /////////////////////////////////////////////////// // Support tests /////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp index 4e30d205f..8b3f4b19e 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp @@ -41,7 +41,7 @@ user_capabilities::user_capabilities(attribute_store::attribute endpoint_node) { this->support_user_schedule = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_USER_SCHEDULE)) .reported(); - this->support_all_user_checksum + this->support_all_users_checksum = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM)) .reported(); this->support_by_user_checksum @@ -54,6 +54,7 @@ user_capabilities::user_capabilities(attribute_store::attribute endpoint_node) { sl_log_error(LOG_TAG, "Something was wrong getting user capabilities : %s", e.what()); + attribute_store_log(); this->is_data_valid = false; } } @@ -116,4 +117,9 @@ bool user_capabilities::is_credential_rule_supported( return (supported_credential_rules_bitmask & (1 << credential_rule)); } +bool user_capabilities::is_all_users_checksum_supported() const +{ + return support_all_users_checksum; +} + } // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h index be04fb393..700602009 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h @@ -79,6 +79,13 @@ class user_capabilities bool is_credential_rule_supported(user_credential_rule_t credential_rule) const; + /** + * @brief Check if all users checksum is supported + * @return true All users checksum is supported + * @return false All users checksum is not supported + */ + bool is_all_users_checksum_supported() const; + private: // Maximum number of users that can be stored in the device uint16_t max_user_count = 0; @@ -91,7 +98,7 @@ class user_capabilities // Device support for scheduling users uint8_t support_user_schedule = 0; // Device support for getting the checksum of all users - uint8_t support_all_user_checksum = 0; + uint8_t support_all_users_checksum = 0; // Device support for getting the checksum of a specific user uint8_t support_by_user_checksum = 0; diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 731ac579a..9a70ead83 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -198,24 +198,14 @@ sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( parser.read_byte( endpoint_node.emplace_node(ATTRIBUTE(MAX_USERNAME_LENGTH))); - constexpr uint8_t SUPPORT_ALL_USERS_CHECKSUM_BITMASK - = USER_CAPABILITIES_REPORT_PROPERTIES1_ALL_USERS_CHECKSUM_SUPPORT_BIT_MASK; - auto support_bits = parser.read_byte_with_bitmask( + parser.read_byte_with_bitmask( {{USER_CAPABILITIES_REPORT_PROPERTIES1_USER_SCHEDULE_SUPPORT_BIT_MASK, endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_USER_SCHEDULE))}, - {SUPPORT_ALL_USERS_CHECKSUM_BITMASK, + {USER_CAPABILITIES_REPORT_PROPERTIES1_ALL_USERS_CHECKSUM_SUPPORT_BIT_MASK, endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ALL_USERS_CHECKSUM))}, {USER_CAPABILITIES_REPORT_PROPERTIES1_USER_CHECKSUM_SUPPORT_BIT_MASK, endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_USER_CHECKSUM))}}); - // SUPPORT_ALL_USERS_CHECKSUM support - if (support_bits[SUPPORT_ALL_USERS_CHECKSUM_BITMASK]) { - sl_log_debug(LOG_TAG, - "SUPPORT_ALL_USERS_CHECKSUM is set, sending All Users " - "Checksum Get Command"); - endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); - } - parser.read_bitmask( endpoint_node.emplace_node(ATTRIBUTE(SUPPORTED_USER_TYPES))); @@ -360,10 +350,64 @@ sl_status_t ///////////////////////////////////////////////////////////////////////////// // All User Checksum Get/Report ///////////////////////////////////////////////////////////////////////////// + +/** + * @brief Add given user node to the checksum calculator + * + * @param user_node User node + * @param checksum_calculator Checksum calculator + * @param include_user_identifier Include the user identifier in the checksum (used in ALL_USERS_CHECKSUM) + */ +void add_user_node_to_checksum( + const attribute_store::attribute &user_node, + user_credential::checksum_calculator &checksum_calculator, + bool include_user_identifier = false) +{ + // Check if we need to add the identifier to the checksum calculation + if (include_user_identifier) { + checksum_calculator.add_node(user_node); + } + + // Gather all the User values + const std::vector user_attributes = { + ATTRIBUTE(USER_TYPE), + ATTRIBUTE(USER_ACTIVE_STATE), + ATTRIBUTE(CREDENTIAL_RULE), + ATTRIBUTE(USER_NAME_ENCODING), + ATTRIBUTE(USER_NAME), + }; + + for (auto attribute: user_attributes) { + checksum_calculator.add_node(user_node.child_by_type(attribute)); + } + + // The all credential data + for (auto credential_type_node: + user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { + for (auto credential_slot_node: + credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!credential_slot_node.reported_exists()) { + sl_log_debug( + LOG_TAG, + "%d reported value is not defined. Not adding to checksum.", + credential_slot_node.value_to_string()); + continue; + } + + // Add credential type to checksum + checksum_calculator.add_node(credential_type_node); + // Add credential slot to checksum + checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node( + credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); + } + } +} + static sl_status_t zwave_command_class_user_credential_all_user_checksum_get( attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) { - sl_log_debug(LOG_TAG, "All User Checksum Get"); + sl_log_debug(LOG_TAG, "All Users Checksum Get"); return frame_generator.generate_no_args_frame(ALL_USERS_CHECKSUM_GET, frame, @@ -375,6 +419,7 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( const uint8_t *frame_data, uint16_t frame_length) { + sl_log_debug(LOG_TAG, "All Users Checksum Report"); constexpr uint8_t expected_size = sizeof(ZW_ALL_USERS_CHECKSUM_REPORT_FRAME); attribute_store::attribute endpoint_node @@ -389,10 +434,35 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( return SL_STATUS_NOT_SUPPORTED; } - parser.read_sequential( + auto received_checksum = parser.read_sequential( 2, endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM))); + // Create the checksum calculator + user_credential::checksum_calculator checksum_calculator; + + // Add all user nodes to the checksum + for (auto user_node: endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { + // Ignore user node 0 + if (user_node.reported_exists() + && user_node.reported() == 0) { + continue; + } + add_user_node_to_checksum(user_node, checksum_calculator, true); + } + + // Compute the checksum + auto computed_checksum = checksum_calculator.compute_checksum(); + if (computed_checksum != received_checksum) { + auto message + = boost::format( + "All Users Checksum mismatch. Received %1$#x but computed %2$#x") + % received_checksum % computed_checksum; + send_message_to_mqtt(SL_LOG_ERROR, message.str()); + return SL_STATUS_FAIL; + } else { + send_message_to_mqtt(SL_LOG_INFO, "All Users Checksum match."); + } } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while parsing All User Checksum Report frame : %s", @@ -1612,8 +1682,14 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( } } else { sl_log_debug(LOG_TAG, "No more users to discover"); + // Check if we supports all users checksum to compute it + user_credential::user_capabilities capabilities(endpoint_node); + if (capabilities.is_all_users_checksum_supported()) { + // This will do nothing if the node already exists + // Otherwise it will trigger all_users_checksum_get + endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); + } } - } catch (const std::exception &e) { sl_log_error(LOG_TAG, "Error while parsing User Report frame : %s", @@ -1740,41 +1816,8 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( // Compute checksum ourselves to see if it matches user_credential::checksum_calculator checksum_calculator; - - // First gather all the User values - const std::vector user_attributes = { - ATTRIBUTE(USER_TYPE), - ATTRIBUTE(USER_ACTIVE_STATE), - ATTRIBUTE(CREDENTIAL_RULE), - ATTRIBUTE(USER_NAME_ENCODING), - ATTRIBUTE(USER_NAME), - }; - for (auto attribute: user_attributes) { - checksum_calculator.add_node(user_node.child_by_type(attribute)); - } - - // The all credential data - for (auto credential_type_node: - user_node.children(ATTRIBUTE(CREDENTIAL_TYPE))) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { - sl_log_debug( - LOG_TAG, - "%d reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); - continue; - } - - // Add credential type to checksum - checksum_calculator.add_node(credential_type_node); - // Add credential slot to checksum - checksum_calculator.add_node(credential_slot_node); - checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); - } - } - + add_user_node_to_checksum(user_node, checksum_calculator); + result = check_checksum_value(user_node, ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), checksum_calculator.compute_checksum(), diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp index b556b3c10..89c2c1fe8 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -761,4 +761,47 @@ sl_status_t zwave_command_class_user_credential_get_credential_checksum( } return SL_STATUS_OK; -} \ No newline at end of file +} + +sl_status_t zwave_command_class_user_credential_get_all_users_checksum( + attribute_store_node_t endpoint_node) +{ + try { + attribute_store::attribute cpp_endpoint_node(endpoint_node); + auto checksum_node + = cpp_endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); + checksum_node.clear_reported(); + checksum_node.clear_desired(); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up get all users checksum : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +bool zwave_command_class_user_credential_supports( + attribute_store_node_t endpoint_node, uint8_t command_id) +{ + // Checks first if the node supports User Credential + auto cpp_endpoint_node = attribute_store::attribute(endpoint_node); + if (!cpp_endpoint_node.child_by_type(ATTRIBUTE(VERSION)).is_valid()) { + return false; + } + + user_credential::user_capabilities user_capabilities(endpoint_node); + //user_credential::credential_capabilities credential_capabilities(endpoint_node); + + switch(command_id) { + case ALL_USERS_CHECKSUM_GET: + return user_capabilities.is_all_users_checksum_supported(); + default: + sl_log_critical( + LOG_TAG, + "Unknown command %d in zwave_command_class_user_credential_supports", + command_id); + return false; + } +} diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h index fc2401091..7fb5c7f2d 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h @@ -344,6 +344,33 @@ sl_status_t zwave_command_class_user_credential_get_credential_checksum( attribute_store_node_t endpoint_node, user_credential_type_t credential_type); + +/** + * @brief Send a All Users Checksum Get command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL otherwise + */ +sl_status_t zwave_command_class_user_credential_get_all_users_checksum( + attribute_store_node_t endpoint_node); + +/** + * @brief Test if given command id is supported by the User Credential Command Class + * + * It will perform a check first to see if given node is supporting the User Credential Command Class. + * If not it will return false. + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param command_id The command id to test + * + * @return true if the command is supported + * @return false if the command is not supported + */ +bool zwave_command_class_user_credential_supports( + attribute_store_node_t endpoint_node, uint8_t command_id); + #ifdef __cplusplus } #endif diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index d5bc653d5..6f1ce1fc5 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -565,21 +565,10 @@ void test_user_credential_user_capabilities_report_happy_case() attribute_store_node_t all_user_checksum_node = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)); - - if (support_all_users_checksum) { - TEST_ASSERT_NOT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - all_user_checksum_node, - "ALL_USERS_CHECKSUM node should exists " - "since all_user_checksum_node == true"); - } else { - TEST_ASSERT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, - all_user_checksum_node, - "ALL_USERS_CHECKSUM node should NOT exists " - "since all_user_checksum_node == false"); - } - - // Remove node for next tests cases - attribute_store_delete_node(all_user_checksum_node); + TEST_ASSERT_EQUAL_MESSAGE(ATTRIBUTE_STORE_INVALID_NODE, + all_user_checksum_node, + "ALL_USERS_CHECKSUM node should NOT exists yet " + "even if support_all_users_checksum == true"); }; printf("Test with first set of data\n"); @@ -704,27 +693,6 @@ void test_user_credential_credential_capabilities_report_happy_case() test_report_values(); } -//////////////////////////////////////////////////////////////////////////// -// All User Checksum Get/Report -//////////////////////////////////////////////////////////////////////////// -void test_user_credential_all_users_checksum_get_happy_case() -{ - helper_test_get_set_frame_happy_case(ALL_USERS_CHECKSUM_GET); -} - -void test_user_credential_all_users_checksum_report_happy_case() -{ - user_credential_all_users_checksum_t expected_checksum = 0xABCD; - - // Report frame - zwave_frame report_frame; - report_frame.add(expected_checksum); - helper_test_report_frame(ALL_USERS_CHECKSUM_REPORT, report_frame); - - // Attribute store test - helper_test_attribute_value(ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum); -} - //////////////////////////////////////////////////////////////////////////// // User Set/Get/Report //////////////////////////////////////////////////////////////////////////// @@ -903,6 +871,26 @@ void test_user_credential_user_report_happy_case() user_credential_user_name_encoding_t user_name_encoding = 0; std::string user_name = "DoUzE"; + // Those functions are exposed and checks user values, so we need to setup the capabilities + uint16_t number_of_users = 1312; + user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; + uint8_t username_max_length = 112; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum + = 1; // Used to check if the user checksum will be computed at the end + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 2; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 0xFF; + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + auto test_user_values = [&](const attribute_store::attribute &user_node) { TEST_ASSERT_EQUAL_MESSAGE( user_id, @@ -992,6 +980,11 @@ void test_user_credential_user_report_happy_case() auto second_user_id_node = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(USER_UNIQUE_ID), 2); + TEST_ASSERT_FALSE_MESSAGE( + cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)) + .is_valid(), + "ALL_USERS_CHECKSUM node should not be created yet"); + printf("Second and last user creation\n"); TEST_ASSERT_EQUAL_MESSAGE( @@ -1050,8 +1043,73 @@ void test_user_credential_user_report_happy_case() EXPECTED_SECOND_USER_ID, second_user_id_node.reported(), "Second user id mismatch"); + + TEST_ASSERT_TRUE_MESSAGE( + cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)) + .is_valid(), + "ALL_USERS_CHECKSUM node should be created"); } +void test_user_credential_no_all_users_checksum() +{ + user_credential_user_unique_id_t next_user_id = 0; + user_credential_modifier_type_t user_modifier_type = 2; + user_credential_modifier_node_id_t user_modifier_node_id = 1313; + user_credential_user_unique_id_t user_id = 12; + user_credential_user_type_t user_type = 3; + user_credential_user_active_state_t user_active_state = 1; + user_credential_supported_credential_rules_t credential_rule = 2; + user_credential_expiring_timeout_minutes_t expiring_timeout_minutes = 1515; + user_credential_user_name_encoding_t user_name_encoding = 0; + std::string user_name = "DoUzE"; + + // Those functions are exposed and checks user values, so we need to setup the capabilities + uint16_t number_of_users = 1312; + user_credential_supported_credential_rules_t cred_rule_bitmask = 0x0F; + uint8_t username_max_length = 112; + uint8_t support_user_schedule = 0; + uint8_t support_all_users_checksum + = 0; // Used to check if the user checksum will be computed at the end + uint8_t support_user_checksum = 0; + uint8_t supported_user_types_bitmask_length = 2; + user_credential_supported_user_type_bitmask_t supported_user_types_bitmask + = 0xFF; + helper_simulate_user_capabilites_report(number_of_users, + cred_rule_bitmask, + username_max_length, + support_user_schedule, + support_all_users_checksum, + support_user_checksum, + supported_user_types_bitmask_length, + supported_user_types_bitmask); + + // Create first user + auto first_user_id_node + = cpp_endpoint_id_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)); + first_user_id_node.set_desired(0); + + zwave_frame get_frame; + get_frame.add(static_cast(0)); + helper_test_get_set_frame_happy_case(USER_GET, first_user_id_node, get_frame); + + // Call report + helper_simulate_user_report_frame(0x04, + next_user_id, + user_modifier_type, + user_modifier_node_id, + user_id, + user_type, + user_active_state, + credential_rule, + expiring_timeout_minutes, + user_name_encoding, + user_name); + + TEST_ASSERT_FALSE_MESSAGE( + cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)) + .is_valid(), + "ALL_USERS_CHECKSUM node should not be created yet"); +} void test_user_credential_user_report_user_with_id0() { // User Report should have returned SL_STATUS_OK and ignore the frame @@ -4082,4 +4140,73 @@ void test_get_credential_checksum_mismatch() } } +//////////////////////////////////////////////////////////////////////////// +// All User Checksum Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_all_users_checksum_get_happy_case() +{ + helper_test_get_set_frame_happy_case(ALL_USERS_CHECKSUM_GET); +} + +void test_user_credential_all_users_checksum_report_no_users_happy_case() +{ + user_credential_all_users_checksum_t expected_checksum = 0x00; + + // Report frame + zwave_frame report_frame; + report_frame.add(expected_checksum); + helper_test_report_frame(ALL_USERS_CHECKSUM_REPORT, report_frame); + + // Attribute store test + helper_test_attribute_value(ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum); +} + +void test_user_credential_all_users_checksum_report_with_users_happy_case() +{ + user_credential_all_users_checksum_t expected_checksum = 0x57b9; + + // Add 2 users and one with credentials + helper_simulate_user_report_frame(0x00, // User Add + 0, + 0, + 0, + 12, + 1, + 1, + 15, + 0, + 0, + "MICHEL"); + helper_simulate_user_report_frame(0x00, // User Add + 0, + 0, + 0, + 1312, + 1, + 1, + 15, + 0, + 0, + "TURBO"); + helper_simulate_credential_report_frame(0x00, // Credential Add + 12, + 1, + 1, + 0, + string_to_uint8_vector("1234"), + 0x02, + 0, + 0, + 0); + // Report frame + zwave_frame report_frame; + report_frame.add(expected_checksum); + helper_test_report_frame(ALL_USERS_CHECKSUM_REPORT, report_frame); + + // Attribute store test + helper_test_attribute_value(ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum); +} + + + } // extern "C" \ No newline at end of file From b58a3da2d123c976886591a2013d6a7e584d9ad6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Thu, 12 Sep 2024 15:03:19 +0200 Subject: [PATCH 52/60] UIC-3222: Admin code support --- .../src/user_credential_cluster_server.cpp | 86 +++++ .../user_credential_cluster_server_test.cpp | 131 ++++++- .../attribute_store_defined_attribute_types.h | 84 +++-- ...wave_command_class_user_credential_types.h | 15 + .../zpc_attribute_store_type_registration.cpp | 6 + .../zwave_command_classes/CMakeLists.txt | 2 + ...ser_credential_credential_capabilities.cpp | 173 +-------- .../user_credential_credential_capabilities.h | 64 +--- ...redential_credential_type_capabilities.cpp | 208 +++++++++++ ..._credential_credential_type_capabilities.h | 94 +++++ .../user_credential_helpers.cpp | 18 + .../user_credential_helpers.hpp | 31 +- .../zwave_command_class_user_credential.cpp | 253 ++++++++++++-- ...wave_command_class_user_credential_api.cpp | 114 +++++- .../zwave_command_class_user_credential_api.h | 24 ++ ...ave_command_class_user_credential_test.cpp | 329 +++++++++++++++--- 16 files changed, 1280 insertions(+), 352 deletions(-) create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp create mode 100644 applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.h diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 36c02ecdd..5add8b2d3 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -615,6 +615,51 @@ sl_status_t credential_type); } +sl_status_t admin_pin_code_set(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type, + const char *credential_data) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + return zwave_command_class_user_credential_supports(endpoint_node, + ADMIN_PIN_CODE_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_set_admin_pin_code( + endpoint_node, + credential_data); +} + +sl_status_t + admin_pin_code_deactivate(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) +{ + attribute_store_node_t endpoint_node + = attribute_store_network_helper_get_endpoint_node(unid, endpoint); + + // Now that we know that the command is supported, return here if it is + // a support check type of call. + if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { + return (zwave_command_class_user_credential_supports(endpoint_node, + ADMIN_PIN_CODE_SET) + && zwave_command_class_user_credential_supports_admin_pin_code_deactivation( + endpoint_node)) + ? SL_STATUS_OK + : SL_STATUS_FAIL; + } + + return zwave_command_class_user_credential_set_admin_pin_code(endpoint_node, + ""); +}; + /////////////////////////////////////////////////////////////////////////////// // Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -634,6 +679,35 @@ void register_attributes_to_mqtt_map( } } +/////////////////////////////////////////////////////////////////////////////// +// Callbacks +////////////////////////////////////////////////////////////////////////////// +void on_admin_pin_code_update(attribute_store_node_t updated_node, + attribute_store_change_t change) +{ + if (change != ATTRIBUTE_UPDATED) { + return; + } + + attribute_store::attribute admin_pin_code_node(updated_node); + if (!admin_pin_code_node.reported_exists()) { + return; + } + + auto raw_pin_code = admin_pin_code_node.reported>(); + std::string pin_code_str(raw_pin_code.begin(), raw_pin_code.end()); + + try { + admin_pin_code_node.first_parent(ATTRIBUTE_ENDPOINT_ID) + .emplace_node(DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_ADMIN_PIN_CODE) + .set_reported(pin_code_str); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while updating ZLC Admin Pin Code attribute : %s", + e.what()); + } +} + /////////////////////////////////////////////////////////////////////////////// // MQTT Helpers functions ////////////////////////////////////////////////////////////////////////////// @@ -1135,5 +1209,17 @@ sl_status_t user_credential_cluster_server_init() // All Users Checksum uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set( &get_all_users_checksum); + // Admin PIN code + uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set( + &admin_pin_code_set); + uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set( + &admin_pin_code_deactivate); + + // Types that can't be mapped with UAM + attribute_store_register_callback_by_type_and_state( + &on_admin_pin_code_update, + ATTRIBUTE(ADMIN_PIN_CODE), + REPORTED_ATTRIBUTE); + return SL_STATUS_OK; } diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index c5262d701..f9e8d1e1f 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -91,6 +91,8 @@ uic_mqtt_dotdot_user_credential_credential_association_callback_t credential_ass uic_mqtt_dotdot_user_credential_get_user_checksum_callback_t get_user_checksum_command = NULL; uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_t get_credential_checksum_command = NULL; uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_t get_all_users_checksum_command = NULL; +uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t set_admin_pin_code_command = NULL; +uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t deactivate_admin_pin_code_command = NULL; // clang-format on // Stub functions for intercepting callback registration. @@ -223,6 +225,20 @@ void uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub( get_all_users_checksum_command = callback; } +void uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_stub( + const uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_t callback, + int cmock_num_calls) +{ + set_admin_pin_code_command = callback; +} + +void uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_stub( + const uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_t + callback, + int cmock_num_calls) +{ + deactivate_admin_pin_code_command = callback; +} /// Setup the test suite (called once before all test_xxx functions are called) void suiteSetUp() @@ -308,6 +324,9 @@ void setUp() // Credential checksum uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_credential_checksum_callback_set_stub); uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_Stub(&uic_mqtt_dotdot_user_credential_get_all_users_checksum_callback_set_stub); + // Admin code + uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_Stub(&uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set_stub); + uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_Stub(&uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set_stub); // clang-format on // Run the component init @@ -321,16 +340,21 @@ void setUp() // Setup helper cpp_endpoint_node = attribute_store::attribute(endpoint_id_node); -} -void set_version(zwave_cc_version_t version) -{ - // Set the version - cpp_endpoint_node - .emplace_node(ATTRIBUTE(VERSION)) - .set_reported(version); + // Setup global cred capabilities + cpp_endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE), + static_cast(1)); + cpp_endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), + static_cast(1)); + cpp_endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION), + static_cast(1)); + + // Set command class version + cpp_endpoint_node.emplace_node(ATTRIBUTE(VERSION)).set_reported(1); } + + ///////////////////////////////////////////////////////////////////////// // Mqtt topics helpers ///////////////////////////////////////////////////////////////////////// @@ -2381,8 +2405,6 @@ void test_user_credential_cluster_test_credential_checksum_happy_case() void test_user_credential_cluster_test_all_users_checksum_happy_case() { - set_version(1); - // Command not supported yet (default user capabilities SUPPORT_ALL_USERS_CHECKSUM set to 0) TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_FAIL, @@ -2428,6 +2450,96 @@ void test_user_credential_cluster_test_all_users_checksum_happy_case() "Checksum node reported value should NOT exists"); } +void test_user_credential_cluster_test_admin_set_command_happy_case() +{ + auto support_admin_pin_code_node + = cpp_endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE)) + .set_reported(0); + auto status + = set_admin_pin_code_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + ""); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + status, + "Admin set should NOT be supported since SUPPORT_ADMIN_PIN_CODE is 0"); + + support_admin_pin_code_node.set_reported(1); + + status + = set_admin_pin_code_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK, + ""); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Admin set should be supported since SUPPORT_ADMIN_PIN_CODE is 1"); + + std::string expected_pin_code = "1234"; + status + = set_admin_pin_code_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL, + expected_pin_code.c_str()); + + auto raw_pin_code + = cpp_endpoint_node.child_by_type(ATTRIBUTE(ADMIN_PIN_CODE)) + .desired>(); + + std::string reported_pin_code; + for (char c : raw_pin_code) { + reported_pin_code += c; + } + + TEST_ASSERT_EQUAL_STRING_MESSAGE(expected_pin_code.c_str(), + reported_pin_code.c_str(), + "Admin pin code mismatch"); +} + +void test_user_credential_cluster_test_admin_deactivate_command_happy_case() +{ + auto support_admin_deactivation_node + = cpp_endpoint_node + .emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION)) + .set_reported(0); + auto status = deactivate_admin_pin_code_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Admin deactivation should NOT be supported since " + "SUPPORT_ADMIN_PIN_CODE_DEACTIVATION is 0"); + + support_admin_deactivation_node.set_reported(1); + + status = deactivate_admin_pin_code_command( + supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_OK, + status, + "Admin deactivation should be supported since SUPPORT_ADMIN_PIN_CODE is 1"); + + status + = deactivate_admin_pin_code_command(supporting_node_unid, + endpoint_id, + UIC_MQTT_DOTDOT_CALLBACK_TYPE_NORMAL); + + std::vector expected_empty_pin_code = {0}; + TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE( + expected_empty_pin_code.data(), + cpp_endpoint_node.child_by_type(ATTRIBUTE(ADMIN_PIN_CODE)) + .desired>() + .data(), + expected_empty_pin_code.size(), + "Admin pin code should be at empty value"); +} /////////////////////////////////////////////////// // Support tests @@ -2538,4 +2650,5 @@ void test_user_credential_cluster_test_user_command_not_supported_happy_case() "Delete user should not be supported"); } + } // extern "C" \ No newline at end of file diff --git a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 534209938..3b084d146 100644 --- a/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h @@ -1141,97 +1141,107 @@ DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_USER_TYPES, /// > Credential Capabilities DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x09)) -DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0B)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0C)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_SUPPORT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0B)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0D)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0C)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0E)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0D)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0F)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0E)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x10)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0F)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x11)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x10)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x12)) /// > All Users Checksum DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ALL_USERS_CHECKSUM, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x11)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x13)) /// > Users DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x12)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x14)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x13)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x15)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_NODE_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x14)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x16)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x15)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x17)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_ACTIVE_STATE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x16)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x18)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x17)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x19)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME_ENCODING, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x18)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1A)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x19)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) /// > Credentials DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1A)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x21)) // Specific to Credential SET DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x22)) // Specific to USER SET DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x21)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x22)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x24)) // Specific to Credential Learn DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_OPERATION_TYPE, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x24)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x25)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x29)) // Specific to Credential User Unique Identifier Credential (UUIC) Association DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_USER_ID, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2A)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x29)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2A)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) // Checksums DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2F)) DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM_MISMATCH_ERROR, - ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x30)) + +// Admin Code +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ADMIN_PIN_CODE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x31)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ADMIN_PIN_CODE_OPERATION_RESULT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x32)) ///////////////////////////////////////////////// // Z-Wave Plus Info CC diff --git a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h index d9c9e77b9..1c96efde4 100644 --- a/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -88,6 +88,21 @@ typedef struct user_credential_credential_identifier { user_credential_slot_t credential_slot; } user_credential_credential_identifier_t; +///> Missing definitions +// Admin PIN Code +#define ADMIN_PIN_CODE_SET 0x1A +#define ADMIN_PIN_CODE_GET 0x1B +#define ADMIN_PIN_CODE_REPORT 0x1C +// Admin PIN Code Report +#define ADMIN_PIN_CODE_REPORT_MODIFIED 0x01 +#define ADMIN_PIN_CODE_REPORT_UNMODIFIED 0x03 +#define ADMIN_PIN_CODE_REPORT_RESPONSE_TO_GET 0x04 +#define ADMIN_PIN_CODE_REPORT_DUPLICATE_CREDENTIAL 0x07 +#define ADMIN_PIN_CODE_REPORT_MANUFACTURER_SECURITY_RULE 0x08 +#define ADMIN_PIN_CODE_REPORT_NOT_SUPPORTED 0x0D +#define ADMIN_PIN_CODE_REPORT_DEACTIVATION_NOT_SUPPORTED 0x0E +#define ADMIN_PIN_CODE_REPORT_UNSPECIFIED_ERROR 0x0F + #ifdef __cplusplus extern "C" { #endif diff --git a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp index c66ca7578..44bcf8f6f 100644 --- a/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp +++ b/applications/zpc/components/zpc_attribute_store/src/zpc_attribute_store_type_registration.cpp @@ -472,6 +472,8 @@ static const std::vector attribute_schema = { // Credential capabilities {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_CREDENTIAL_CHECKSUM, "User Credential Support Credential Checksum", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE, "User Credential Support Credential Admin Code", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORT_ADMIN_PIN_CODE_DEACTIVATION, "User Credential Support Admin Code Deactivation", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, "User Credential Supported Credential Type", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_SUPPORT, "User Credential Learn Support", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U8_STORAGE_TYPE}, {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, "User Credential Supported Slot Count", ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPE, U16_STORAGE_TYPE}, @@ -516,6 +518,10 @@ static const std::vector attribute_schema = { // Only one learn can be active at the time, so we make this attribute on the endpoint node {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, "User Credential Credential Learn Stop Flag", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + // Admin + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ADMIN_PIN_CODE, "User Credential Admin Code", ATTRIBUTE_ENDPOINT_ID, BYTE_ARRAY_STORAGE_TYPE}, + {ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ADMIN_PIN_CODE_OPERATION_RESULT, "User Credential Admin Code Operation Result", ATTRIBUTE_ENDPOINT_ID, U8_STORAGE_TYPE}, + ///////////////////////////////////////////////////////////////////// // Z-Wave Plus Info Command Class attributes ///////////////////////////////////////////////////////////////////// diff --git a/applications/zpc/components/zwave_command_classes/CMakeLists.txt b/applications/zpc/components/zwave_command_classes/CMakeLists.txt index 66ea91414..2d4e7fe81 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -68,7 +68,9 @@ add_library( src/zwave_command_class_protocol.c src/private/user_credential/user_credential_user_capabilities.cpp src/private/user_credential/user_credential_credential_capabilities.cpp + src/private/user_credential/user_credential_credential_type_capabilities.cpp src/private/user_credential/user_credential_checksum_calculator.cpp + src/private/user_credential/user_credential_helpers.cpp ) install(TARGETS zwave_command_classes LIBRARY DESTINATION lib) diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp index b70fbbf3c..c3536c901 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp @@ -16,11 +16,6 @@ // Get attribute store names #include "attribute_store_defined_attribute_types.h" -// UTF16 conversion (deprecated in C++17 but we don't have a better alternative yet) -// Needed for credential data (password) per specification -#include -#include - // Boost #include @@ -31,50 +26,22 @@ namespace user_credential { credential_capabilities::credential_capabilities( - const attribute_store::attribute &endpoint_node, - user_credential_type_t credential_type) + const attribute_store::attribute &endpoint_node) { this->is_data_valid = false; try { - auto supported_credential_type_node = endpoint_node.child_by_type_and_value( - ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), - credential_type); - - if (!supported_credential_type_node.is_valid()) { - sl_log_error( - LOG_TAG, - "Credential type %d not supported. Can't get capabilities for it.", - credential_type); - return; - } - - this->max_slot_count - = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT)) - .reported(); - this->learn_support = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT)) - .reported(); - this->min_credential_length - = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_MIN_LENGTH)) + this->credential_checksum_support + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM)) .reported(); - this->max_credential_length - = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_MAX_LENGTH)) + this->admin_code_support + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE)) .reported(); - this->learn_recommended_timeout - = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)) - .reported(); - this->learn_number_of_steps - = supported_credential_type_node - .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS)) + this->admin_code_deactivation_support + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION)) .reported(); - this->credential_type = credential_type; - this->is_data_valid = true; + this->is_data_valid = true; } catch (std::exception &e) { sl_log_error(LOG_TAG, "Something was wrong getting credential capabilities : %s", @@ -82,127 +49,17 @@ credential_capabilities::credential_capabilities( } } -bool credential_capabilities::is_learn_supported() const +bool credential_capabilities::has_credential_checksum_support() const { - return is_data_valid && learn_support > 0; -} - -bool credential_capabilities::is_credential_valid( - user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const std::vector &credential_data) const -{ - if (!is_data_valid) { - sl_log_error( - LOG_TAG, - "Credential capabilities are not valid. Try restarting the device."); - return false; - } - - if (credential_type != this->credential_type) { - sl_log_error(LOG_TAG, "Credential type mismatch."); - return false; - } - - if (!is_slot_valid(credential_slot)) { - sl_log_error( - LOG_TAG, - "Slot ID is not valid. Given : %d, Max Supported Slot count : %d", - credential_slot, - max_slot_count); - return false; - } - - if (!is_credential_data_valid(credential_data)) { - sl_log_error(LOG_TAG, - "Credential data size is not valid. Should be between %d " - "and %d, given : %d", - min_credential_length, - max_credential_length, - credential_data.size()); - return false; - } - - return true; + return is_data_valid && credential_checksum_support > 0; } - -bool credential_capabilities::is_slot_valid( - user_credential_slot_t credential_slot) const +bool credential_capabilities::has_admin_code_support() const { - return credential_slot <= max_slot_count; + return is_data_valid && admin_code_support > 0; } - -bool credential_capabilities::is_credential_data_valid( - const std::vector &credential_data) const -{ - return (credential_data.size() >= min_credential_length - && credential_data.size() <= max_credential_length); -} - -std::vector - credential_capabilities::convert_and_validate_credential_data( - const char *credential_data, user_credential_slot_t credential_slot) const -{ - std::vector credential_data_vector - = convert_credential_data(credential_data); - - // Credential not valid, we are not adding it - if (!this->is_credential_valid(this->credential_type, - credential_slot, - credential_data_vector)) { - throw std::runtime_error("Credential capabilities are not valid."); - } - - return credential_data_vector; -} - -std::vector - credential_capabilities::convert_credential_data(const char *credential_data) const -{ - std::vector credential_data_vector; - std::string credential_data_str(credential_data); - switch (credential_type) { - case CREDENTIAL_REPORT_PASSWORD: { - // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order - auto credential_data_utf16 = utf8_to_utf16(credential_data_str); - for (const auto &c: credential_data_utf16) { - credential_data_vector.push_back((uint8_t)(c >> 8)); - credential_data_vector.push_back((uint8_t)c); - } - } break; - case CREDENTIAL_REPORT_PIN_CODE: - for (const auto &c: credential_data_str) { - if (c < '0' || c > '9') { - throw std::runtime_error( - (boost::format("Invalid character in PIN code : %1%. Only digits " - "are allowed.") - % c) - .str()); - } - credential_data_vector.push_back(c); - } - break; - default: - for (const auto &c: credential_data_str) { - credential_data_vector.push_back(c); - } - } - - return credential_data_vector; -} - -uint8_t credential_capabilities::get_learn_recommended_timeout() const -{ - return learn_recommended_timeout; -} - -std::u16string credential_capabilities::utf8_to_utf16(const std::string &utf8) const +bool credential_capabilities::has_admin_code_deactivation_support() const { - std::wstring_convert, char16_t> cnv; - std::u16string s = cnv.from_bytes(utf8); - if (cnv.converted() < utf8.size()) - throw std::runtime_error("Something went wrong converting UTF8 to UTF16"); - return s; + return is_data_valid && admin_code_deactivation_support > 0; } -} // namespace user_credential \ No newline at end of file +} // namespace user_credential diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h index fe2c354a3..8a1cc9df7 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h @@ -14,14 +14,8 @@ #ifndef USER_CREDENTIAL_CREDENTIAL_CAPABILITIES_H #define USER_CREDENTIAL_CREDENTIAL_CAPABILITIES_H -// Cpp definitions -#include -#include - // Attribute store #include "attribute.hpp" -// User credential types -#include "zwave_command_class_user_credential_types.h" namespace user_credential { @@ -30,61 +24,17 @@ class credential_capabilities { public: explicit credential_capabilities( - const attribute_store::attribute &endpoint_node, - user_credential_type_t credential_type); + const attribute_store::attribute &endpoint_node); ~credential_capabilities() = default; - bool is_learn_supported() const; - - bool is_credential_valid(user_credential_type_t credential_type, - user_credential_slot_t credential_slot, - const std::vector &credential_data) const; - - bool is_slot_valid(user_credential_slot_t credential_slot) const; - bool - is_credential_data_valid(const std::vector &credential_data) const; - - /** - * @brief Convert and validate credential data str to a vector of uint8_t - * - * Convenience function to convert data and check if it is valid as per the credential capabilities. - * - * @param credential_data Credential data to convert - * @param credential_slot Credential slot - * - * @throws std::runtime_error if the credential data is invalid - * - * @return The converted data - */ - std::vector convert_and_validate_credential_data( - const char *credential_data, user_credential_slot_t credential_slot) const; - - /** - * @brief Convert credential data str to a vector of uint8_t - * - * @note CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order - * - * @param credential_data Credential data to convert - * - * @throws std::runtime_error if the credential data is invalid - * - * @return The converted data -*/ - std::vector convert_credential_data(const char *credential_data) const; - - uint8_t get_learn_recommended_timeout() const; + bool has_credential_checksum_support() const; + bool has_admin_code_support() const; + bool has_admin_code_deactivation_support() const; private: - - std::u16string utf8_to_utf16(const std::string &utf8) const; - - user_credential_type_t credential_type = 0; - uint16_t max_slot_count = 0; - uint8_t learn_support = 0; - uint8_t min_credential_length = 0; - uint8_t max_credential_length = 0; - uint8_t learn_recommended_timeout = 0; - uint8_t learn_number_of_steps = 0; + uint8_t credential_checksum_support = 0; + uint8_t admin_code_support = 0; + uint8_t admin_code_deactivation_support = 0; bool is_data_valid = false; }; diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp new file mode 100644 index 000000000..8d434a7ac --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp @@ -0,0 +1,208 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#include "user_credential_credential_type_capabilities.h" + +// Get attribute store names +#include "attribute_store_defined_attribute_types.h" + +// UTF16 conversion (deprecated in C++17 but we don't have a better alternative yet) +// Needed for credential data (password) per specification +#include +#include + +// Boost +#include + +// Common definitions +#include "user_credential_definitions.hpp" + +namespace user_credential +{ + +credential_type_capabilities::credential_type_capabilities( + const attribute_store::attribute &endpoint_node, + user_credential_type_t credential_type) +{ + this->is_data_valid = false; + + try { + auto supported_credential_type_node = endpoint_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + credential_type); + + if (!supported_credential_type_node.is_valid()) { + sl_log_error( + LOG_TAG, + "Credential type %d not supported. Can't get capabilities for it.", + credential_type); + return; + } + + this->max_slot_count + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_SUPPORTED_SLOT_COUNT)) + .reported(); + this->learn_support = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_SUPPORT)) + .reported(); + this->min_credential_length + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_MIN_LENGTH)) + .reported(); + this->max_credential_length + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_MAX_LENGTH)) + .reported(); + this->learn_recommended_timeout + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT)) + .reported(); + this->learn_number_of_steps + = supported_credential_type_node + .child_by_type(ATTRIBUTE(CREDENTIAL_LEARN_NUMBER_OF_STEPS)) + .reported(); + + this->credential_type = credential_type; + this->is_data_valid = true; + } catch (std::exception &e) { + sl_log_error(LOG_TAG, + "Something was wrong getting credential capabilities : %s", + e.what()); + } +} + +bool credential_type_capabilities::is_learn_supported() const +{ + return is_data_valid && learn_support > 0; +} + +bool credential_type_capabilities::is_credential_valid( + user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::vector &credential_data) const +{ + if (!is_data_valid) { + sl_log_error( + LOG_TAG, + "Credential capabilities are not valid. Try restarting the device."); + return false; + } + + if (credential_type != this->credential_type) { + sl_log_error(LOG_TAG, "Credential type mismatch."); + return false; + } + + if (!is_slot_valid(credential_slot)) { + sl_log_error( + LOG_TAG, + "Slot ID is not valid. Given : %d, Max Supported Slot count : %d", + credential_slot, + max_slot_count); + return false; + } + + if (!is_credential_data_valid(credential_data)) { + sl_log_error(LOG_TAG, + "Credential data size is not valid. Should be between %d " + "and %d, given : %d", + min_credential_length, + max_credential_length, + credential_data.size()); + return false; + } + + return true; +} + +bool credential_type_capabilities::is_slot_valid( + user_credential_slot_t credential_slot) const +{ + return credential_slot <= max_slot_count; +} + +bool credential_type_capabilities::is_credential_data_valid( + const std::vector &credential_data) const +{ + return (credential_data.size() >= min_credential_length + && credential_data.size() <= max_credential_length); +} + +std::vector + credential_type_capabilities::convert_and_validate_credential_data( + const char *credential_data, user_credential_slot_t credential_slot) const +{ + std::vector credential_data_vector + = convert_credential_data(credential_data); + + // Credential not valid, we are not adding it + if (!this->is_credential_valid(this->credential_type, + credential_slot, + credential_data_vector)) { + throw std::runtime_error("Credential capabilities are not valid."); + } + + return credential_data_vector; +} + +std::vector + credential_type_capabilities::convert_credential_data(const char *credential_data) const +{ + std::vector credential_data_vector; + std::string credential_data_str(credential_data); + switch (credential_type) { + case CREDENTIAL_REPORT_PASSWORD: { + // CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + auto credential_data_utf16 = utf8_to_utf16(credential_data_str); + for (const auto &c: credential_data_utf16) { + credential_data_vector.push_back((uint8_t)(c >> 8)); + credential_data_vector.push_back((uint8_t)c); + } + } break; + case CREDENTIAL_REPORT_PIN_CODE: + for (const auto &c: credential_data_str) { + if (c < '0' || c > '9') { + throw std::runtime_error( + (boost::format("Invalid character in PIN code : %1%. Only digits " + "are allowed.") + % c) + .str()); + } + credential_data_vector.push_back(c); + } + break; + default: + for (const auto &c: credential_data_str) { + credential_data_vector.push_back(c); + } + } + + return credential_data_vector; +} + +uint8_t credential_type_capabilities::get_learn_recommended_timeout() const +{ + return learn_recommended_timeout; +} + +std::u16string credential_type_capabilities::utf8_to_utf16(const std::string &utf8) const +{ + std::wstring_convert, char16_t> cnv; + std::u16string s = cnv.from_bytes(utf8); + if (cnv.converted() < utf8.size()) + throw std::runtime_error("Something went wrong converting UTF8 to UTF16"); + return s; +} + +} // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.h new file mode 100644 index 000000000..4f71aede7 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.h @@ -0,0 +1,94 @@ +/****************************************************************************** + * # License + * Copyright 2024 Silicon Laboratories Inc. www.silabs.com + ****************************************************************************** + * The licensor of this software is Silicon Laboratories Inc. Your use of this + * software is governed by the terms of Silicon Labs Master Software License + * Agreement (MSLA) available at + * www.silabs.com/about-us/legal/master-software-license-agreement. This + * software is distributed to you in Source Code format and is governed by the + * sections of the MSLA applicable to Source Code. + * + *****************************************************************************/ + +#ifndef USER_CREDENTIAL_CREDENTIAL_TYPE_CAPABILITIES_H +#define USER_CREDENTIAL_CREDENTIAL_TYPE_CAPABILITIES_H + +// Cpp definitions +#include +#include + +// Attribute store +#include "attribute.hpp" +// User credential types +#include "zwave_command_class_user_credential_types.h" + +namespace user_credential +{ + +class credential_type_capabilities +{ + public: + explicit credential_type_capabilities( + const attribute_store::attribute &endpoint_node, + user_credential_type_t credential_type); + ~credential_type_capabilities() = default; + + bool is_learn_supported() const; + + bool is_credential_valid(user_credential_type_t credential_type, + user_credential_slot_t credential_slot, + const std::vector &credential_data) const; + + bool is_slot_valid(user_credential_slot_t credential_slot) const; + bool + is_credential_data_valid(const std::vector &credential_data) const; + + /** + * @brief Convert and validate credential data str to a vector of uint8_t + * + * Convenience function to convert data and check if it is valid as per the credential capabilities. + * + * @param credential_data Credential data to convert + * @param credential_slot Credential slot + * + * @throws std::runtime_error if the credential data is invalid + * + * @return The converted data + */ + std::vector convert_and_validate_credential_data( + const char *credential_data, user_credential_slot_t credential_slot) const; + + /** + * @brief Convert credential data str to a vector of uint8_t + * + * @note CC:0083.01.0A.11.021 Passwords MUST be transmitted in Unicode UTF-16 format, in big endian order + * + * @param credential_data Credential data to convert + * + * @throws std::runtime_error if the credential data is invalid + * + * @return The converted data +*/ + std::vector convert_credential_data(const char *credential_data) const; + + uint8_t get_learn_recommended_timeout() const; + + private: + + std::u16string utf8_to_utf16(const std::string &utf8) const; + + user_credential_type_t credential_type = 0; + uint16_t max_slot_count = 0; + uint8_t learn_support = 0; + uint8_t min_credential_length = 0; + uint8_t max_credential_length = 0; + uint8_t learn_recommended_timeout = 0; + uint8_t learn_number_of_steps = 0; + + bool is_data_valid = false; +}; + +} // namespace user_credential + +#endif // USER_CREDENTIAL_CREDENTIAL_TYPE_CAPABILITIES_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp index 907357a19..a0f48d093 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp @@ -13,8 +13,11 @@ // Get attribute store names #include "user_credential_helpers.hpp" +// Boost #include "boost/format.hpp" +// Cpp standard includes +#include namespace user_credential_helpers { @@ -272,4 +275,19 @@ credential_id_nodes get_credential_identifier_nodes( return nodes; } +bool is_admin_code_empty(const std::vector& admin_pin_code) +{ + return admin_pin_code.size() == 1 && admin_pin_code[0] == 0; +} + +void set_empty_admin_code(attribute_store::attribute &admin_pin_code_node, + attribute_store_node_value_state_t state) +{ + if (!admin_pin_code_node.is_valid()) { + throw std::runtime_error("Admin code node is not valid."); + } + std::vector empty_code = {0}; + admin_pin_code_node.set(state, empty_code); +} + } // namespace user_credential_helpers \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp index 4e138a75e..cf67f66bc 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp @@ -19,10 +19,8 @@ // User credential types #include "zwave_command_class_user_credential_types.h" -// Cpp +// Unify Cpp #include "attribute.hpp" - - #include "user_credential_definitions.hpp" namespace user_credential_helpers @@ -254,5 +252,30 @@ credential_id_nodes get_credential_identifier_nodes( identifier_state credential_type, identifier_state credential_slot); -} // namespace user_credential +/** + * @brief Return true if given admin pin code is considered empty + * + * We need this function since the attribute store doesn't support empty vector. + * + * @param admin_pin_code Admin pin code + * + * @return true Admin pin code is empty + * @return false Admin pin code is not empty + */ +bool is_admin_code_empty(const std::vector& admin_pin_code); +/** + * @brief Set the admin pin code node to an empty value + * + * We need this function since the attribute store doesn't support empty vector. + * + * @param admin_pin_code_node Admin pin code node + * @param state State (REPORTED or DESIRED) + * + * @throws std::runtime_error If admin_pin_code_node is not valid + */ +void set_empty_admin_code(attribute_store::attribute &admin_pin_code_node, + attribute_store_node_value_state_t state); + +} // namespace user_credential_helpers + #endif // USER_CREDENTIAL_HELPERS_H \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 9a70ead83..1b5c08d75 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -53,6 +53,7 @@ #include "private/user_credential/user_credential_definitions.hpp" #include "private/user_credential/user_credential_user_capabilities.h" #include "private/user_credential/user_credential_credential_capabilities.h" +#include "private/user_credential/user_credential_credential_type_capabilities.h" #include "private/user_credential/user_credential_checksum_calculator.h" #include "private/user_credential/user_credential_helpers.hpp" @@ -75,9 +76,11 @@ namespace zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); // Callbacks -std::set user_credential_slot_changed_callback; -std::set user_credential_slot_message_callback; -} +std::set + user_credential_slot_changed_callback; +std::set + user_credential_slot_message_callback; +} // namespace ///////////////////////////////////////////////////////////////////////////// // Callbacks @@ -114,7 +117,9 @@ void send_message_to_mqtt(sl_log_level level, const std::string &message) ///////////////////////////////////////////////////////////////////////////// // Helpers ///////////////////////////////////////////////////////////////////////////// -std::string get_credential_type_debug_str(user_credential_type_t credential_type) { +std::string + get_credential_type_debug_str(user_credential_type_t credential_type) +{ auto fmt = boost::format("Credential Type %1% (%2%)") % cred_type_get_enum_value_name(credential_type) % static_cast(credential_type); @@ -257,10 +262,17 @@ sl_status_t return SL_STATUS_FAIL; } - // TODO: Add admin code support - parser.read_byte_with_bitmask( + const uint8_t support_admin_code_bitmask = 0x40; + auto result = parser.read_byte_with_bitmask( {{CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK, - endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM))}}); + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM))}, + {support_admin_code_bitmask, endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE))}, + {0x20, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION))}}); + + if (result[support_admin_code_bitmask]) { + endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE)); + } uint8_t supported_credential_types_count = parser.read_byte(); @@ -419,7 +431,7 @@ sl_status_t zwave_command_class_user_credential_all_user_checksum_handle_report( const uint8_t *frame_data, uint16_t frame_length) { - sl_log_debug(LOG_TAG, "All Users Checksum Report"); + sl_log_debug(LOG_TAG, "All Users Checksum Report"); constexpr uint8_t expected_size = sizeof(ZW_ALL_USERS_CHECKSUM_REPORT_FRAME); attribute_store::attribute endpoint_node @@ -800,9 +812,9 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( case credential_report_type_t::CREDENTIAL_UNCHANGED: send_message_to_mqtt(SL_LOG_INFO, "Credential Unchanged. Type " - + get_credential_type_debug_str(credential_type) - + ", Slot " + std::to_string(credential_slot) - + " (User " + std::to_string(user_id) + ")"); + + get_credential_type_debug_str(credential_type) + + ", Slot " + std::to_string(credential_slot) + + " (User " + std::to_string(user_id) + ")"); return SL_STATUS_OK; // Update desired value if found, otherwise create the nodes case credential_report_type_t::RESPONSE_TO_GET: @@ -826,7 +838,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( return SL_STATUS_OK; } else { sl_log_debug(LOG_TAG, - "First credential : Updating credential type and slot for user %d", + "First credential : Updating credential type and slot " + "for user %d", user_id); credential_type_node.set_reported(credential_type); credential_slot_node.clear_desired(); @@ -1114,7 +1127,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_status_report( {credential_slot, DESIRED_OR_REPORTED_ATTRIBUTE}); // Get operation type so we can handle error cases - // We use desired or reported here since it can be set to reported by the + // We use desired or reported here since it can be set to reported by the // supervision process. auto operation_type = credential_id_nodes.slot_node @@ -1273,11 +1286,17 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( sl_log_debug(LOG_TAG, "User Unique Identifier Credential Association Report."); - sl_log_debug(LOG_TAG,"\tSource User ID: %d", source_user_id); - sl_log_debug(LOG_TAG,"\tSource Credential Type: %d", source_credential_type); - sl_log_debug(LOG_TAG,"\tSource Credential Slot: %d", source_credential_slot); - sl_log_debug(LOG_TAG,"\tDestination User ID: %d", destination_user_id); - sl_log_debug(LOG_TAG,"\tDestination Credential Slot: %d", destination_credential_slot); + sl_log_debug(LOG_TAG, "\tSource User ID: %d", source_user_id); + sl_log_debug(LOG_TAG, + "\tSource Credential Type: %d", + source_credential_type); + sl_log_debug(LOG_TAG, + "\tSource Credential Slot: %d", + source_credential_slot); + sl_log_debug(LOG_TAG, "\tDestination User ID: %d", destination_user_id); + sl_log_debug(LOG_TAG, + "\tDestination Credential Slot: %d", + destination_credential_slot); // Get nodes auto source_credential_nodes = get_credential_identifier_nodes( @@ -1302,9 +1321,11 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( // If something went wrong end device side, log the error and return // This should handle the slot already taken case if (association_status != USER_CREDENTIAL_ASSOCIATION_REPORT_SUCCESS) { - send_message_to_mqtt(SL_LOG_ERROR, - "User Unique Identifier Credential Association error. " - "Reported status code : " + std::to_string(association_status)); + send_message_to_mqtt( + SL_LOG_ERROR, + "User Unique Identifier Credential Association error. " + "Reported status code : " + + std::to_string(association_status)); return SL_STATUS_OK; } @@ -1318,7 +1339,7 @@ sl_status_t zwave_command_class_user_credential_uuic_association_report( .str()); source_credential_slot_node.set_reported(destination_credential_slot); - + // Need to move to new user if (destination_user_id != source_user_id) { sl_log_debug(LOG_TAG, "Moving slot to new user"); @@ -1817,7 +1838,7 @@ sl_status_t zwave_command_class_user_credential_user_checksum_handle_report( // Compute checksum ourselves to see if it matches user_credential::checksum_calculator checksum_calculator; add_user_node_to_checksum(user_node, checksum_calculator); - + result = check_checksum_value(user_node, ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), checksum_calculator.compute_checksum(), @@ -1959,12 +1980,13 @@ sl_status_t if (result == SL_STATUS_OK) { send_message_to_mqtt(SL_LOG_INFO, - "Credential Checksum for " + cred_type_get_enum_value_name(credential_type) + "Credential Checksum for " + + cred_type_get_enum_value_name(credential_type) + " is correct."); } else { send_message_to_mqtt(SL_LOG_ERROR, "Mismatch Credential Checksum for " - + cred_type_get_enum_value_name(credential_type)); + + cred_type_get_enum_value_name(credential_type)); } } catch (const std::exception &e) { sl_log_error(LOG_TAG, @@ -1976,6 +1998,177 @@ sl_status_t return result; } +///////////////////////////////////////////////////////////////////////////// +// Admin code Set/Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t zwave_command_class_user_credential_admin_pin_code_set( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Admin PIN Code Set"); + + try { + // Node setup + attribute_store::attribute admin_pin_code_node(node); + + // Get Values + std::vector admin_pin_code + = admin_pin_code_node.desired>(); + + // This represents the case where the admin pin code is empty + // We need this workaround because attribute store doesn't support empty values as + // they are treated as non existing + if (is_admin_code_empty(admin_pin_code)) { + admin_pin_code.clear(); + } + + user_credential::credential_capabilities credential_capabilities( + admin_pin_code_node.first_parent(ATTRIBUTE_ENDPOINT_ID)); + + if (admin_pin_code.empty() + && !credential_capabilities.has_admin_code_deactivation_support()) { + send_message_to_mqtt(SL_LOG_ERROR, + "Admin PIN code is empty and the device doesn't " + "support deactivation. Not sending Admin PIN code."); + return SL_STATUS_NOT_SUPPORTED; + } + + // 2 for header + // 1 for length + const uint8_t admin_code_size = static_cast(admin_pin_code.size()); + const uint8_t expected_frame_size = admin_code_size + 3; + + // Creating the frame + frame_generator.initialize_frame(ADMIN_PIN_CODE_SET, + frame, + expected_frame_size); + + // In every case we add 0 to the frame + frame_generator.add_raw_byte(admin_code_size); + + // Do not add anything to the frame if the admin pin code is empty + if (!admin_pin_code.empty()) { + frame_generator.add_value(admin_pin_code_node, + DESIRED_OR_REPORTED_ATTRIBUTE); + } + + frame_generator.validate_frame(frame_length); + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while generating Admin PIN Code frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + return SL_STATUS_OK; +} + +static sl_status_t zwave_command_class_user_credential_admin_pin_code_get( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Admin PIN Code Get"); + // No definition yet for ADMIN_PIN_CODE_GET we use raw value + return frame_generator.generate_no_args_frame(ADMIN_PIN_CODE_GET, frame, frame_length); +} + +sl_status_t zwave_command_class_user_credential_admin_pin_code_handle_report( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + sl_log_debug(LOG_TAG, "Admin PIN Code Report"); + + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); + + const uint8_t min_size = 3; + + try { + zwave_frame_parser parser(frame_data, frame_length); + // 0xF since the size of the Admin PIN code is on 4 bits + if (!parser.is_frame_size_valid(min_size, min_size + 0xF)) { + sl_log_error(LOG_TAG, + "Invalid frame size for Admin PIN Code Report frame"); + return SL_STATUS_FAIL; + } + + // Parse the frame + constexpr uint8_t admin_code_op_result_bitmask = 0b11110000; + constexpr uint8_t admin_code_length_bitmask = 0b00001111; + // First parse the code size and operation result + auto result = parser.read_byte_with_bitmask({ + {admin_code_op_result_bitmask, + endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE_OPERATION_RESULT))}, + {admin_code_length_bitmask}}); + + auto admin_code_op_result = result[admin_code_op_result_bitmask]; + switch (admin_code_op_result) { + case ADMIN_PIN_CODE_REPORT_MODIFIED: // Modified + break; + case ADMIN_PIN_CODE_REPORT_UNMODIFIED: // Unmodified + send_message_to_mqtt(SL_LOG_INFO, "Admin PIN code is unchanged."); + break; + case ADMIN_PIN_CODE_REPORT_RESPONSE_TO_GET: // Response to get + break; + case ADMIN_PIN_CODE_REPORT_DUPLICATE_CREDENTIAL: // Duplicate Credential + send_message_to_mqtt(SL_LOG_ERROR, + "Admin Code was not modified - a duplicate PIN " + "code exists in the Credential database."); + break; + case ADMIN_PIN_CODE_REPORT_MANUFACTURER_SECURITY_RULE: // Manufacturer Security Rule + send_message_to_mqtt(SL_LOG_ERROR, + "Admin Code was not modified as the provided code " + "fails a manufacturer security rule"); + break; + case ADMIN_PIN_CODE_REPORT_NOT_SUPPORTED: // Admin Code not supported + send_message_to_mqtt(SL_LOG_ERROR, + "Admin Code was not modified as the device does " + "not support Admin Code functionality."); + break; + case ADMIN_PIN_CODE_REPORT_DEACTIVATION_NOT_SUPPORTED: // Admin Code Deactivation not supported + send_message_to_mqtt( + SL_LOG_ERROR, + "Admin Code was not modified as the device does " + "not support Admin Code deactivation functionality."); + break; + case ADMIN_PIN_CODE_REPORT_UNSPECIFIED_ERROR: // Unspecified Node Error + send_message_to_mqtt( + SL_LOG_ERROR, + "Unknown issue with Get/Set Admin Code operation."); + break; + default: + send_message_to_mqtt(SL_LOG_ERROR, + "Admin PIN Code unknown Operation Result."); + return SL_STATUS_FAIL; + } + + // Modified or Response to get + if (admin_code_op_result == ADMIN_PIN_CODE_REPORT_RESPONSE_TO_GET + || admin_code_op_result == ADMIN_PIN_CODE_REPORT_MODIFIED) { + auto admin_code_size = result[admin_code_length_bitmask]; + sl_log_debug(LOG_TAG, "Admin PIN Code size : %d", admin_code_size); + + auto admin_pin_code_node + = endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE)); + + if (admin_code_size != 0) { + parser.read_sequential>(admin_code_size, + admin_pin_code_node); + } else { + // Since set an empty vector is not supported we delete the node + sl_log_debug(LOG_TAG, "Admin PIN Code is empty."); + set_empty_admin_code(admin_pin_code_node, REPORTED_ATTRIBUTE); + } + } + + return SL_STATUS_OK; + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing Admin Pin Report frame : %s", + e.what()); + return SL_STATUS_FAIL; + } + return SL_STATUS_OK; +} + ///////////////////////////////////////////////////////////////////////////// // Post interview actions ///////////////////////////////////////////////////////////////////////////// @@ -2101,6 +2294,11 @@ sl_status_t zwave_command_class_user_credential_control_handler( connection_info, frame_data, frame_length); + case 0x1C: // ADMIN_PIN_CODE_REPORT + return zwave_command_class_user_credential_admin_pin_code_handle_report( + connection_info, + frame_data, + frame_length); default: return SL_STATUS_NOT_SUPPORTED; } @@ -2173,6 +2371,11 @@ sl_status_t zwave_command_class_user_credential_init() NULL, &zwave_command_class_user_credential_credential_checksum_get); + attribute_resolver_register_rule( + ATTRIBUTE(ADMIN_PIN_CODE), + &zwave_command_class_user_credential_admin_pin_code_set, + &zwave_command_class_user_credential_admin_pin_code_get); + // https://github.com/Z-Wave-Alliance/AWG/pull/124#discussion_r1484473752 // Discussion about delaying the user interview process after the inclusion diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp index 89c2c1fe8..7d0f4e6aa 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -13,10 +13,13 @@ #include "zwave_command_class_user_credential_api.h" +#include "zap-types.h" + // Private definitions #include "private/user_credential/user_credential_helpers.hpp" #include "private/user_credential/user_credential_user_capabilities.h" #include "private/user_credential/user_credential_credential_capabilities.h" +#include "private/user_credential/user_credential_credential_type_capabilities.h" // Cpp includes #include @@ -60,7 +63,7 @@ sl_status_t zwave_command_class_user_credential_add_new_user( user_credential_user_name_encoding_t user_name_encoding, const char *user_name) { - // Debug info + // Debug info sl_log_debug( LOG_TAG, "zwave_command_class_user_credential_add_new_user called with : "); @@ -72,7 +75,6 @@ sl_status_t zwave_command_class_user_credential_add_new_user( sl_log_debug(LOG_TAG, "\tuser_name_encoding : %d", user_name_encoding); sl_log_debug(LOG_TAG, "\tuser_name : %s", user_name); - auto endpoint_node = attribute_store::attribute(node); // Check user id @@ -267,8 +269,8 @@ sl_status_t zwave_command_class_user_credential_add_new_credential( } auto capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); if (!capabilities.is_slot_valid(credential_slot)) { sl_log_error(LOG_TAG, @@ -354,8 +356,8 @@ sl_status_t zwave_command_class_user_credential_modify_credential( auto credential_slot_node = nodes.slot_node; // Process credential data auto capabilities - = user_credential::credential_capabilities(endpoint_node, - credential_type); + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); std::vector credential_data_vector = capabilities.convert_and_validate_credential_data(credential_data, credential_slot); @@ -520,10 +522,11 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( "\tcredential_learn_timeout : %d", credential_learn_timeout); - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + auto credential_type_capabilities + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); - if (!credential_capabilities.is_learn_supported()) { + if (!credential_type_capabilities.is_learn_supported()) { sl_log_error(LOG_TAG, "Learn is not supported for credential type %d. Not starting " "learn process.", @@ -531,7 +534,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( return SL_STATUS_FAIL; } - if (!credential_capabilities.is_slot_valid(credential_slot)) { + if (!credential_type_capabilities.is_slot_valid(credential_slot)) { sl_log_error(LOG_TAG, "Credential slot %d is not valid for Credential Type %d. Not " "starting learn process.", @@ -573,7 +576,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_add( if (credential_learn_timeout == 0) { credential_learn_timeout - = credential_capabilities.get_learn_recommended_timeout(); + = credential_type_capabilities.get_learn_recommended_timeout(); sl_log_debug(LOG_TAG, "Credential learn timeout is 0. Setting it to default " "reported value (%d seconds).", @@ -613,10 +616,11 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( "\tcredential_learn_timeout : %d", credential_learn_timeout); - auto credential_capabilities - = user_credential::credential_capabilities(endpoint_node, credential_type); + auto credential_type_capabilities + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); - if (!credential_capabilities.is_learn_supported()) { + if (!credential_type_capabilities.is_learn_supported()) { sl_log_error(LOG_TAG, "Learn is not supported for credential type %d. Not starting " "learn process.", @@ -634,7 +638,7 @@ sl_status_t zwave_command_class_user_credential_credential_learn_start_modify( if (credential_learn_timeout == 0) { credential_learn_timeout - = credential_capabilities.get_learn_recommended_timeout(); + = credential_type_capabilities.get_learn_recommended_timeout(); sl_log_debug(LOG_TAG, "Credential learn timeout is 0. Setting it to default " "reported value (%d seconds).", @@ -782,21 +786,85 @@ sl_status_t zwave_command_class_user_credential_get_all_users_checksum( return SL_STATUS_OK; } +sl_status_t zwave_command_class_user_credential_set_admin_pin_code( + attribute_store_node_t endpoint_node, const char *raw_credential_data) +{ + try { + // Capabilities + user_credential::credential_type_capabilities credential_type_capabilities( + endpoint_node, + ZCL_CRED_TYPE_PIN_CODE); + user_credential::credential_capabilities credential_capabilities( + endpoint_node); + + // Base check + if (!credential_capabilities.has_admin_code_support()) { + sl_log_error( + LOG_TAG, + "Admin PIN code not supported."); + return SL_STATUS_FAIL; + } + + // Get credential data in the right format + auto credential_data + = credential_type_capabilities.convert_credential_data(raw_credential_data); + + // Create or get admin pin code node + auto admin_pin_code_node = attribute_store::attribute(endpoint_node) + .emplace_node(ATTRIBUTE(ADMIN_PIN_CODE)); + + // Check if we can deactivate it + if (credential_data.empty() + && !credential_capabilities.has_admin_code_deactivation_support()) { + sl_log_error( + LOG_TAG, + "Admin PIN code deactivation disabled, can't deactivate it."); + return SL_STATUS_FAIL; + } + + // Special case if credential data is empty + // Need this since no value is the same as undefined for the attribute store + if (credential_data.empty()) { + sl_log_debug(LOG_TAG, "Admin pin code data is empty. Deactivating it."); + set_empty_admin_code(admin_pin_code_node, DESIRED_ATTRIBUTE); + } else if (credential_type_capabilities.is_credential_data_valid( + credential_data)) { + // Set new value for desired node + admin_pin_code_node.set_desired(credential_data); + } else { + sl_log_error(LOG_TAG, + "Admin pin code data is not valid. Not setting it."); + return SL_STATUS_FAIL; + } + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while setting up set admin pin code : %s", + e.what()); + return SL_STATUS_FAIL; + } + return SL_STATUS_OK; +} + bool zwave_command_class_user_credential_supports( attribute_store_node_t endpoint_node, uint8_t command_id) -{ +{ // Checks first if the node supports User Credential auto cpp_endpoint_node = attribute_store::attribute(endpoint_node); if (!cpp_endpoint_node.child_by_type(ATTRIBUTE(VERSION)).is_valid()) { return false; } - + user_credential::user_capabilities user_capabilities(endpoint_node); - //user_credential::credential_capabilities credential_capabilities(endpoint_node); + user_credential::credential_capabilities credential_capabilities( + endpoint_node); - switch(command_id) { + switch (command_id) { case ALL_USERS_CHECKSUM_GET: return user_capabilities.is_all_users_checksum_supported(); + case ADMIN_PIN_CODE_SET: + case ADMIN_PIN_CODE_GET: + return credential_capabilities.has_admin_code_support(); default: sl_log_critical( LOG_TAG, @@ -805,3 +873,11 @@ bool zwave_command_class_user_credential_supports( return false; } } + +bool zwave_command_class_user_credential_supports_admin_pin_code_deactivation( + attribute_store_node_t endpoint_node) +{ + user_credential::credential_capabilities credential_capabilities( + endpoint_node); + return credential_capabilities.has_admin_code_deactivation_support(); +} diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h index 7fb5c7f2d..83e662fa2 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h @@ -356,6 +356,30 @@ sl_status_t zwave_command_class_user_credential_get_credential_checksum( sl_status_t zwave_command_class_user_credential_get_all_users_checksum( attribute_store_node_t endpoint_node); +/** + * @brief Send a Set Admin Pin Code command to the end device + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * @param credential_data The new admin pin code. Must contains only digits. + * + * @return sl_status_t SL_STATUS_OK if the attribute store was updated successfully + * @return sl_status_t SL_STATUS_FAIL if the credential_data is invalid. + */ +sl_status_t zwave_command_class_user_credential_set_admin_pin_code( + attribute_store_node_t endpoint_node, + const char* credential_data); + +/** + * @brief Return true if the User Credential Command Class supports the Admin Pin Code Deactivation command + * + * @param endpoint_node The attribute store node of the endpoint where the user credential is located. + * + * @return true if the command is supported + * @return false if the command is not supported + */ +bool zwave_command_class_user_credential_supports_admin_pin_code_deactivation( + attribute_store_node_t endpoint_node); + /** * @brief Test if given command id is supported by the User Credential Command Class * diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 6f1ce1fc5..4a078c9f9 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -57,21 +57,21 @@ extern "C" { #define ATTRIBUTE(type) ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_##type -const resolver_function_map attributes_binding = { - {ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, - {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, - {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, - {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, - {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, - {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}, - {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), {0, CREDENTIAL_LEARN_START}}, - {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}, - {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), - {0, USER_CREDENTIAL_ASSOCIATION_SET}}, - {ATTRIBUTE(USER_CHECKSUM), {USER_CHECKSUM_GET, 0}}, - {ATTRIBUTE(CREDENTIAL_CHECKSUM), {CREDENTIAL_CHECKSUM_GET, 0}}, -}; +const resolver_function_map attributes_binding + = {{ATTRIBUTE(NUMBER_OF_USERS), {USER_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), {CREDENTIAL_CAPABILITIES_GET, 0}}, + {ATTRIBUTE(ALL_USERS_CHECKSUM), {ALL_USERS_CHECKSUM_GET, 0}}, + {ATTRIBUTE(USER_UNIQUE_ID), {USER_GET, 0}}, + {ATTRIBUTE(USER_OPERATION_TYPE), {0, USER_SET}}, + {ATTRIBUTE(CREDENTIAL_SLOT), {CREDENTIAL_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), {0, CREDENTIAL_SET}}, + {ATTRIBUTE(CREDENTIAL_LEARN_OPERATION_TYPE), {0, CREDENTIAL_LEARN_START}}, + {ATTRIBUTE(CREDENTIAL_LEARN_STOP), {0, CREDENTIAL_LEARN_CANCEL}}, + {ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + {0, USER_CREDENTIAL_ASSOCIATION_SET}}, + {ATTRIBUTE(USER_CHECKSUM), {USER_CHECKSUM_GET, 0}}, + {ATTRIBUTE(CREDENTIAL_CHECKSUM), {CREDENTIAL_CHECKSUM_GET, 0}}, + {ATTRIBUTE(ADMIN_PIN_CODE), {ADMIN_PIN_CODE_GET, ADMIN_PIN_CODE_SET}}}; // Tested command class handler const zwave_struct_handler_args command_class_handler @@ -160,6 +160,8 @@ void helper_simulate_user_capabilites_report( void helper_simulate_credential_capabilites_report( uint8_t credential_checksum_support, + uint8_t admin_code_support, + uint8_t admin_code_deactivation_support, std::vector credential_type, std::vector cl_support, std::vector supported_credential_slots, @@ -182,7 +184,9 @@ void helper_simulate_credential_capabilites_report( zwave_frame report_frame; - report_frame.add(static_cast(credential_checksum_support << 7)); + report_frame.add(static_cast( + credential_checksum_support << 7 | admin_code_support << 6 + | admin_code_deactivation_support << 5)); report_frame.add(static_cast(credential_type.size())); for (auto &c: credential_type) { @@ -434,6 +438,8 @@ void helper_create_credential_checksum_structure() // Create simulated envrionment for credentials helper_simulate_credential_capabilites_report(1, + 1, + 1, {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_PASSWORD, ZCL_CRED_TYPE_EYE_BIOMETRIC}, @@ -607,6 +613,8 @@ void test_user_credential_credential_capabilities_get_happy_case() void test_user_credential_credential_capabilities_report_happy_case() { uint8_t credential_checksum_support = 1; + uint8_t admin_code_support = 1; + uint8_t admin_code_deactivation_support = 1; std::vector credential_type = {1, 3, 4, 5}; std::vector cl_support = {1, 0, 0, 1}; std::vector supported_credential_slots = {1233, 11233, 21233, 33}; @@ -619,6 +627,22 @@ void test_user_credential_credential_capabilities_report_happy_case() auto test_report_values = [&]() { helper_test_attribute_value(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), credential_checksum_support); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE), + admin_code_support); + helper_test_attribute_value(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION), + admin_code_deactivation_support); + auto admin_code_node + = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ADMIN_PIN_CODE)); + if (admin_code_support == 1) { + TEST_ASSERT_TRUE_MESSAGE(admin_code_node.is_valid(), + "Admin code node should exists"); + // For next tests + admin_code_node.delete_node(); + } else { + TEST_ASSERT_FALSE_MESSAGE(admin_code_node.is_valid(), + "Admin code node should NOT exists"); + } + helper_test_attribute_value( DOTDOT_ATTRIBUTE_ID_USER_CREDENTIAL_SUPPORTED_CREDENTIAL_TYPES, expected_credential_type_mask); @@ -660,6 +684,8 @@ void test_user_credential_credential_capabilities_report_happy_case() printf("Test with first set of data\n"); helper_simulate_credential_capabilites_report(credential_checksum_support, + admin_code_support, + admin_code_deactivation_support, credential_type, cl_support, supported_credential_slots, @@ -671,17 +697,21 @@ void test_user_credential_credential_capabilities_report_happy_case() test_report_values(); printf("Test with second set of data\n"); - credential_checksum_support = 0; - credential_type = {6, 7, 8}; - cl_support = {0, 1, 1}; - supported_credential_slots = {15, 1565, 153}; - min_length = {155, 15, 5}; - max_length = {180, 111, 11}; - cl_timeout = {0, 10, 12}; - cl_steps = {0, 1, 2}; - expected_credential_type_mask = 0b11100000; + credential_checksum_support = 0; + admin_code_support = 0; + admin_code_deactivation_support = 0; + credential_type = {6, 7, 8}; + cl_support = {0, 1, 1}; + supported_credential_slots = {15, 1565, 153}; + min_length = {155, 15, 5}; + max_length = {180, 111, 11}; + cl_timeout = {0, 10, 12}; + cl_steps = {0, 1, 2}; + expected_credential_type_mask = 0b11100000; helper_simulate_credential_capabilites_report(credential_checksum_support, + admin_code_support, + admin_code_deactivation_support, credential_type, cl_support, supported_credential_slots, @@ -1639,7 +1669,9 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; @@ -1647,6 +1679,8 @@ void test_user_credential_add_credential_already_defined_cred_type_and_slot() std::vector supported_cred_min_length = {2}; std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -1723,7 +1757,9 @@ void test_user_credential_add_credential_invalid_slot() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; @@ -1731,6 +1767,8 @@ void test_user_credential_add_credential_invalid_slot() std::vector supported_cred_min_length = {2}; std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -1984,7 +2022,9 @@ void test_user_credential_credential_add_modify_delete_happy_case() = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1}; @@ -1992,6 +2032,8 @@ void test_user_credential_credential_add_modify_delete_happy_case() std::vector supported_cred_min_length = {2}; std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -2367,7 +2409,9 @@ void test_user_credential_credential_add_capabilites_failure_cases() sizeof(user_id)); // Se capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1}; @@ -2375,6 +2419,8 @@ void test_user_credential_credential_add_capabilites_failure_cases() std::vector supported_cred_min_length = {2}; std::vector supported_cred_max_length = {6}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -2437,7 +2483,9 @@ void test_user_credential_credential_add_capabilites_happy_case() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_HAND_BIOMETRIC, ZCL_CRED_TYPE_PIN_CODE}; std::vector supported_cl = {1, 0}; @@ -2445,6 +2493,8 @@ void test_user_credential_credential_add_capabilites_happy_case() std::vector supported_cred_min_length = {2, 4}; std::vector supported_cred_max_length = {6, 8}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -2485,7 +2535,9 @@ void test_user_credential_credential_modify_capabilites_failure_cases() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Se capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1}; @@ -2493,6 +2545,8 @@ void test_user_credential_credential_modify_capabilites_failure_cases() std::vector supported_cred_min_length = {2}; std::vector supported_cred_max_length = {7}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -2945,7 +2999,9 @@ void test_user_credential_credential_learn_start_add_happy_case() = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -2955,6 +3011,8 @@ void test_user_credential_credential_learn_start_add_happy_case() std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3028,7 +3086,9 @@ void test_user_credential_credential_learn_start_add_cl_not_supported() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; @@ -3038,6 +3098,8 @@ void test_user_credential_credential_learn_start_add_cl_not_supported() std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3068,7 +3130,9 @@ void test_user_credential_credential_learn_start_add_slot_not_supported() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3078,6 +3142,8 @@ void test_user_credential_credential_learn_start_add_slot_not_supported() std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3108,7 +3174,9 @@ void test_user_credential_credential_learn_start_add_type_not_supported() cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3118,6 +3186,8 @@ void test_user_credential_credential_learn_start_add_type_not_supported() std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3155,7 +3225,9 @@ void test_user_credential_credential_learn_start_add_credential_already_exists() REPORTED_ATTRIBUTE); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3165,6 +3237,8 @@ void test_user_credential_credential_learn_start_add_credential_already_exists() std::vector supported_cl_timeout = {10, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3199,7 +3273,9 @@ void test_user_credential_credential_learn_start_modify_happy_case() REPORTED_ATTRIBUTE); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3209,6 +3285,8 @@ void test_user_credential_credential_learn_start_modify_happy_case() std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3275,7 +3353,9 @@ void test_user_credential_credential_learn_start_modify_cl_not_supported() REPORTED_ATTRIBUTE); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; @@ -3285,6 +3365,8 @@ void test_user_credential_credential_learn_start_modify_cl_not_supported() std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3316,7 +3398,9 @@ void test_user_credential_credential_learn_start_modify_credential_not_existing( cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); // Set capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {0, 1}; @@ -3326,6 +3410,8 @@ void test_user_credential_credential_learn_start_modify_credential_not_existing( std::vector supported_cl_timeout = {0, 2}; std::vector supported_cl_steps = {0, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3364,7 +3450,9 @@ void test_user_credential_credential_learn_cancel_happy_case() void test_user_credential_uuic_association_same_slot_different_user() { // Capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3374,6 +3462,8 @@ void test_user_credential_uuic_association_same_slot_different_user() std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3472,7 +3562,9 @@ void test_user_credential_uuic_association_same_slot_different_user() void test_user_credential_uuic_association_different_slot_different_user_with_existing_type() { // Capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3482,6 +3574,8 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3585,7 +3679,9 @@ void test_user_credential_uuic_association_different_slot_different_user_with_ex void test_user_credential_uuic_association_different_slot_same_user() { // Capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3595,6 +3691,8 @@ void test_user_credential_uuic_association_different_slot_same_user() std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -3691,7 +3789,9 @@ void test_user_credential_uuic_association_different_slot_same_user() void test_user_credential_uuic_association_error_code() { // Capabilities - uint8_t supported_credential_checksum = 1; + uint8_t supported_credential_checksum = 1; + uint8_t support_admin_code = 1; + uint8_t support_admin_code_deactivation = 1; std::vector supported_credential_type = {ZCL_CRED_TYPE_PIN_CODE, ZCL_CRED_TYPE_HAND_BIOMETRIC}; std::vector supported_cl = {1, 1}; @@ -3701,6 +3801,8 @@ void test_user_credential_uuic_association_error_code() std::vector supported_cl_timeout = {20, 2}; std::vector supported_cl_steps = {1, 95}; helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, supported_credential_type, supported_cl, supported_credential_slots, @@ -4207,6 +4309,147 @@ void test_user_credential_all_users_checksum_report_with_users_happy_case() helper_test_attribute_value(ATTRIBUTE(ALL_USERS_CHECKSUM), expected_checksum); } +//////////////////////////////////////////////////////////////////////////// +// Admin PIN code Set/Get/Support +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_admin_pin_code_get_happy_case() +{ + helper_test_get_set_frame_happy_case(ADMIN_PIN_CODE_GET); +} + +void helper_setup_credential_capabilities_admin_code( + uint8_t support_admin_code = 1, uint8_t support_admin_code_deactivation = 1) +{ + uint8_t supported_credential_checksum = 1; + std::vector supported_credential_type + = {ZCL_CRED_TYPE_PIN_CODE}; + std::vector supported_cl = {1}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {6}; + helper_simulate_credential_capabilites_report(supported_credential_checksum, + support_admin_code, + support_admin_code_deactivation, + supported_credential_type, + supported_cl, + supported_credential_slots, + supported_cred_min_length, + supported_cred_max_length, + {1}, + {1}); +} +void test_user_credential_admin_pin_code_set_happy_case() +{ + helper_setup_credential_capabilities_admin_code(); + + std::string admin_pin_code = "1312"; + auto admin_pin_code_data = string_to_uint8_vector(admin_pin_code); + + auto status = zwave_command_class_user_credential_set_admin_pin_code( + endpoint_id_node, + admin_pin_code.c_str()); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Set Admin PIN API command should have worked"); + + auto admin_pin_code_node + = helper_test_and_get_node(ATTRIBUTE(ADMIN_PIN_CODE)); + + zwave_frame set_frame; + set_frame.add(admin_pin_code_data); + + helper_test_get_set_frame_happy_case(ADMIN_PIN_CODE_SET, + admin_pin_code_node, + set_frame); +} + +void test_user_credential_admin_pin_code_set_deactivation_happy_case() +{ + helper_setup_credential_capabilities_admin_code(); + + auto status + = zwave_command_class_user_credential_set_admin_pin_code(endpoint_id_node, + ""); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_OK, + status, + "Set Admin PIN API command should have worked"); + + auto admin_pin_code_node + = helper_test_and_get_node(ATTRIBUTE(ADMIN_PIN_CODE)); + + zwave_frame set_frame; + set_frame.add(static_cast(0)); + helper_test_get_set_frame_happy_case(ADMIN_PIN_CODE_SET, + admin_pin_code_node, + set_frame); +} + +void test_user_credential_admin_pin_code_set_deactivation_not_supported() +{ + helper_setup_credential_capabilities_admin_code(1, 0); + + auto status + = zwave_command_class_user_credential_set_admin_pin_code(endpoint_id_node, + ""); + TEST_ASSERT_EQUAL_MESSAGE(SL_STATUS_FAIL, + status, + "Set Admin PIN API command should NOT have worked"); + + auto admin_pin_code_node + = helper_test_and_get_node(ATTRIBUTE(ADMIN_PIN_CODE)); + + helper_test_get_set_fail_case(ADMIN_PIN_CODE_SET, + SL_STATUS_NOT_SUPPORTED, + admin_pin_code_node); +} + +void test_user_credential_admin_pin_code_report_happy_case() +{ + auto expected_admin_pin_code = string_to_uint8_vector("1312"); + uint8_t admin_pin_code_size + = static_cast(expected_admin_pin_code.size()); + uint8_t expected_operation_result = 0x04; + + // Report frame + zwave_frame report_frame; + uint8_t size_byte = (expected_operation_result << 4) | admin_pin_code_size; + report_frame.add(size_byte); + for (uint8_t c: expected_admin_pin_code) { + report_frame.add(c); + } + + helper_test_report_frame(ADMIN_PIN_CODE_REPORT, report_frame); + + // Attribute store test + helper_test_attribute_value(ATTRIBUTE(ADMIN_PIN_CODE_OPERATION_RESULT), + expected_operation_result); + helper_test_attribute_value(ATTRIBUTE(ADMIN_PIN_CODE), + expected_admin_pin_code); +} +void test_user_credential_admin_pin_code_report_deletion_happy_case() +{ + // Simulate report with 0 as pin code size + uint8_t admin_pin_code_size = 0; + uint8_t expected_operation_result = 0x04; + + // Simulate already present code + auto admin_pin_code_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE)); + admin_pin_code_node.set_reported(string_to_uint8_vector("1312")); + + // Report frame + zwave_frame report_frame; + uint8_t size_byte = (expected_operation_result << 4) | admin_pin_code_size; + report_frame.add(size_byte); + + helper_test_report_frame(ADMIN_PIN_CODE_REPORT, report_frame); + + // Attribute store test + helper_test_attribute_value(ATTRIBUTE(ADMIN_PIN_CODE_OPERATION_RESULT), + expected_operation_result); + std::vector empty_vector = {0}; + helper_test_attribute_value(ATTRIBUTE(ADMIN_PIN_CODE), empty_vector); +} } // extern "C" \ No newline at end of file From 2cd1a906dcedc2d6f2d024ba31e0980cdd8e95c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 17 Sep 2024 12:15:44 +0200 Subject: [PATCH 53/60] UIC-3222: Use zwave_command_class_user_credential_supports API for commands --- .../src/user_credential_cluster_server.cpp | 194 ++++++++---------- ...ser_credential_credential_capabilities.cpp | 9 +- .../user_credential_credential_capabilities.h | 6 +- .../user_credential_user_capabilities.cpp | 12 +- .../user_credential_user_capabilities.h | 13 ++ .../zwave_command_class_user_credential.cpp | 2 +- ...wave_command_class_user_credential_api.cpp | 33 ++- 7 files changed, 142 insertions(+), 127 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 5add8b2d3..ec057ae00 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -138,12 +138,9 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, USER_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_add_new_user( @@ -175,12 +172,9 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, USER_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_modify_user( @@ -208,12 +202,9 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, USER_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_user(endpoint_node, @@ -235,12 +226,10 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_add_new_credential( @@ -266,11 +255,10 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_modify_credential( endpoint_node, @@ -294,12 +282,10 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_credential( @@ -320,12 +306,9 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, USER_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_all_users(endpoint_node); @@ -342,12 +325,10 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_all_credentials( @@ -366,12 +347,10 @@ static sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_all_credentials_by_type( @@ -391,12 +370,10 @@ static sl_status_t delete_all_credentials_for_user( // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_all_credentials_for_user( @@ -417,12 +394,10 @@ static sl_status_t delete_all_credentials_for_user_by_type( // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_delete_all_credentials_for_user_by_type( @@ -446,12 +421,10 @@ sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_LEARN_START) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_credential_learn_start_add( @@ -477,12 +450,10 @@ sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_LEARN_START) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_credential_learn_start_modify( @@ -504,12 +475,10 @@ sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_LEARN_CANCEL) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_credential_learn_stop( @@ -531,12 +500,11 @@ sl_status_t uuic_association_set(dotdot_unid_t unid, // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports( + endpoint_node, + USER_CREDENTIAL_ASSOCIATION_SET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_uuic_association_set( @@ -548,9 +516,10 @@ sl_status_t uuic_association_set(dotdot_unid_t unid, destination_credential_slot); } -sl_status_t get_all_users_checksum(dotdot_unid_t unid, - dotdot_endpoint_id_t endpoint, - uic_mqtt_dotdot_callback_call_type_t call_type) +sl_status_t + get_all_users_checksum(dotdot_unid_t unid, + dotdot_endpoint_id_t endpoint, + uic_mqtt_dotdot_callback_call_type_t call_type) { attribute_store_node_t endpoint_node = attribute_store_network_helper_get_endpoint_node(unid, endpoint); @@ -564,7 +533,8 @@ sl_status_t get_all_users_checksum(dotdot_unid_t unid, : SL_STATUS_FAIL; } - return zwave_command_class_user_credential_get_all_users_checksum(endpoint_node); + return zwave_command_class_user_credential_get_all_users_checksum( + endpoint_node); } sl_status_t get_user_checksum(dotdot_unid_t unid, @@ -578,12 +548,10 @@ sl_status_t get_user_checksum(dotdot_unid_t unid, // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + USER_CHECKSUM_GET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_get_user_checksum(endpoint_node, @@ -602,12 +570,10 @@ sl_status_t // Now that we know that the command is supported, return here if it is // a support check type of call. if (UIC_MQTT_DOTDOT_CALLBACK_TYPE_SUPPORT_CHECK == call_type) { - attribute_store_node_t user_count_node - = attribute_store_get_first_child_by_type(endpoint_node, - ATTRIBUTE(NUMBER_OF_USERS)); - - return attribute_store_node_exists(user_count_node) ? SL_STATUS_OK - : SL_STATUS_FAIL; + return zwave_command_class_user_credential_supports(endpoint_node, + CREDENTIAL_CHECKSUM_GET) + ? SL_STATUS_OK + : SL_STATUS_FAIL; } return zwave_command_class_user_credential_get_credential_checksum( @@ -1139,11 +1105,14 @@ void on_user_credential_message(sl_log_level_t log_level, const std::string message) { nlohmann::json payload; - payload["level"] = log_level; - payload["message"] = message; + payload["level"] = log_level; + payload["message"] = message; std::string payload_str = payload.dump(); - uic_mqtt_publish("ucl/Event", payload_str.c_str(), payload_str.length(), true); + uic_mqtt_publish("ucl/Event", + payload_str.c_str(), + payload_str.length(), + true); } /////////////////////////////////////////////////////////////////////////////// @@ -1213,13 +1182,12 @@ sl_status_t user_credential_cluster_server_init() uic_mqtt_dotdot_user_credential_set_admin_pin_code_callback_set( &admin_pin_code_set); uic_mqtt_dotdot_user_credential_deactivate_admin_pin_code_callback_set( - &admin_pin_code_deactivate); + &admin_pin_code_deactivate); // Types that can't be mapped with UAM - attribute_store_register_callback_by_type_and_state( - &on_admin_pin_code_update, - ATTRIBUTE(ADMIN_PIN_CODE), - REPORTED_ATTRIBUTE); + attribute_store_register_callback_by_type_and_state(&on_admin_pin_code_update, + ATTRIBUTE(ADMIN_PIN_CODE), + REPORTED_ATTRIBUTE); return SL_STATUS_OK; } diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp index c3536c901..0d8f5e639 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp @@ -38,7 +38,8 @@ credential_capabilities::credential_capabilities( = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE)) .reported(); this->admin_code_deactivation_support - = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION)) + = endpoint_node + .child_by_type(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION)) .reported(); this->is_data_valid = true; @@ -49,15 +50,15 @@ credential_capabilities::credential_capabilities( } } -bool credential_capabilities::has_credential_checksum_support() const +bool credential_capabilities::is_credential_checksum_supported() const { return is_data_valid && credential_checksum_support > 0; } -bool credential_capabilities::has_admin_code_support() const +bool credential_capabilities::is_admin_code_supported() const { return is_data_valid && admin_code_support > 0; } -bool credential_capabilities::has_admin_code_deactivation_support() const +bool credential_capabilities::is_admin_code_deactivation_supported() const { return is_data_valid && admin_code_deactivation_support > 0; } diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h index 8a1cc9df7..eb5fb3dc2 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h @@ -27,9 +27,9 @@ class credential_capabilities const attribute_store::attribute &endpoint_node); ~credential_capabilities() = default; - bool has_credential_checksum_support() const; - bool has_admin_code_support() const; - bool has_admin_code_deactivation_support() const; + bool is_credential_checksum_supported() const; + bool is_admin_code_supported() const; + bool is_admin_code_deactivation_supported() const; private: uint8_t credential_checksum_support = 0; diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp index 8b3f4b19e..833327cae 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp @@ -119,7 +119,17 @@ bool user_capabilities::is_credential_rule_supported( bool user_capabilities::is_all_users_checksum_supported() const { - return support_all_users_checksum; + return is_data_valid && support_all_users_checksum > 0; +} + +bool user_capabilities::is_user_checksum_supported() const +{ + return is_data_valid && support_by_user_checksum > 0; +} + +bool user_capabilities::is_user_schedule_supported() const +{ + return is_data_valid && support_user_schedule > 0; } } // namespace user_credential \ No newline at end of file diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h index 700602009..e450e269e 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h @@ -86,6 +86,19 @@ class user_capabilities */ bool is_all_users_checksum_supported() const; + /** + * @brief Check if user checksum is supported + * @return true User checksum is supported + * @return false User checksum is not supported + */ + bool is_user_checksum_supported() const; + /** + * @brief Check if user schedule is supported + * @return true User schedule is supported + * @return false User schedule is not supported + */ + bool is_user_schedule_supported() const; + private: // Maximum number of users that can be stored in the device uint16_t max_user_count = 0; diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 1b5c08d75..f76947bef 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -2025,7 +2025,7 @@ static sl_status_t zwave_command_class_user_credential_admin_pin_code_set( admin_pin_code_node.first_parent(ATTRIBUTE_ENDPOINT_ID)); if (admin_pin_code.empty() - && !credential_capabilities.has_admin_code_deactivation_support()) { + && !credential_capabilities.is_admin_code_deactivation_supported()) { send_message_to_mqtt(SL_LOG_ERROR, "Admin PIN code is empty and the device doesn't " "support deactivation. Not sending Admin PIN code."); diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp index 7d0f4e6aa..f1c45093d 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -798,7 +798,7 @@ sl_status_t zwave_command_class_user_credential_set_admin_pin_code( endpoint_node); // Base check - if (!credential_capabilities.has_admin_code_support()) { + if (!credential_capabilities.is_admin_code_supported()) { sl_log_error( LOG_TAG, "Admin PIN code not supported."); @@ -815,7 +815,7 @@ sl_status_t zwave_command_class_user_credential_set_admin_pin_code( // Check if we can deactivate it if (credential_data.empty() - && !credential_capabilities.has_admin_code_deactivation_support()) { + && !credential_capabilities.is_admin_code_deactivation_supported()) { sl_log_error( LOG_TAG, "Admin PIN code deactivation disabled, can't deactivate it."); @@ -855,6 +855,26 @@ bool zwave_command_class_user_credential_supports( return false; } + // Commands that don't need specific capabilities + // Note : We don't have the granularity to check if the learn is supported for a specific credential at this level + // so some commands (e.g CREDENTIAL_LEARN_START) are marked as supported even if the credential type doesn't support it. + // The API call will check that for us instead. + const std::vector supported_commands = { + USER_SET, + CREDENTIAL_SET, + CREDENTIAL_LEARN_START, + CREDENTIAL_LEARN_CANCEL, + USER_CREDENTIAL_ASSOCIATION_SET + }; + + // Check if we support the command_id without checking the capabilities + if (std::find(supported_commands.begin(), + supported_commands.end(), + command_id) + != supported_commands.end()) { + return true; + } + user_credential::user_capabilities user_capabilities(endpoint_node); user_credential::credential_capabilities credential_capabilities( endpoint_node); @@ -862,9 +882,12 @@ bool zwave_command_class_user_credential_supports( switch (command_id) { case ALL_USERS_CHECKSUM_GET: return user_capabilities.is_all_users_checksum_supported(); + case USER_CHECKSUM_GET: + return user_capabilities.is_user_checksum_supported(); + case CREDENTIAL_CHECKSUM_GET: + return credential_capabilities.is_credential_checksum_supported(); case ADMIN_PIN_CODE_SET: - case ADMIN_PIN_CODE_GET: - return credential_capabilities.has_admin_code_support(); + return credential_capabilities.is_admin_code_supported(); default: sl_log_critical( LOG_TAG, @@ -879,5 +902,5 @@ bool zwave_command_class_user_credential_supports_admin_pin_code_deactivation( { user_credential::credential_capabilities credential_capabilities( endpoint_node); - return credential_capabilities.has_admin_code_deactivation_support(); + return credential_capabilities.is_admin_code_deactivation_supported(); } From ac9e313714790d6dfd939b588ebecb1350887c4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 17 Sep 2024 15:07:29 +0200 Subject: [PATCH 54/60] UIC-3222: Fix user added twice --- .../src/zwave_command_class_user_credential.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index f76947bef..3f8a97512 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -1607,13 +1607,9 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( // Each report type has a different behavior attribute_store::attribute current_user_id_node; switch (user_report_type) { - // Need to create new user node + // In either case we want to create the user node if it doesn't exists + // or update the desired value if it does case user_report_type_t::USER_ADDED: - current_user_id_node - = endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), - current_user_id); - // If this is the first user we get it might not exists yet so we create it. - // Otherwise we just update the reported value case user_report_type_t::RESPONSE_TO_GET: current_user_id_node = create_or_update_desired_value(endpoint_node, From 9fd64a2df48db06a16e1f76f422384b84296afc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Wed, 18 Sep 2024 12:04:41 +0200 Subject: [PATCH 55/60] UIC-3222: Sonar fixes --- .../src/user_credential_cluster_server.cpp | 16 +- .../user_credential_helpers.cpp | 11 +- .../zwave_command_class_user_credential.cpp | 169 ++++++++++-------- .../src/zwave_command_class_user_credential.h | 2 +- 4 files changed, 108 insertions(+), 90 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index ec057ae00..4afbf6f69 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -903,13 +903,13 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value std::string output; - auto data = updated_node_cpp.reported>(); + auto raw_data = updated_node_cpp.reported>(); // Check if we need to convert the value to UTF-8 if (need_utf8_conversion) { std::u16string utf16_str; - for (size_t i = 0; i < data.size(); i += 2) { - char16_t char16 = (data[i] << 8) | data[i + 1]; + for (size_t i = 0; i < raw_data.size(); i += 2) { + char16_t char16 = (raw_data[i] << 8) | raw_data[i + 1]; utf16_str.push_back(char16); } std::wstring_convert, char16_t> cnv; @@ -918,8 +918,8 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, sl_log_error(LOG_TAG, "Error converting UTF-16 to UTF-8"); } } else { - output.reserve(data.size()); - for (auto c: data) { + output.reserve(raw_data.size()); + for (auto c: raw_data) { output.push_back(static_cast(c)); } } @@ -1005,7 +1005,7 @@ void publish_mqtt_topic(const std::string &base_topic, void on_attribute_update( attribute_store_node_t updated_node, attribute_store_change_t change, - std::function get_base_mqtt_topic, + const std::function& get_base_mqtt_topic, const user_attributes_mqtt_map_t &attributes) { try { @@ -1087,7 +1087,7 @@ void on_uuic_slot_update( old_credential_slot.credential_type); // Simulate deletion of the old slot // First simulate deletion of all attributes - for (auto [attribute_store_type, mqtt_data]: credential_attributes) { + for (const auto& [attribute_store_type, mqtt_data]: credential_attributes) { std::string mqtt_topic = mqtt_topic_add_attribute(old_credential_topic, mqtt_data.topic); uic_mqtt_publish(mqtt_topic.c_str(), "", 0, true); @@ -1102,7 +1102,7 @@ void on_uuic_slot_update( } void on_user_credential_message(sl_log_level_t log_level, - const std::string message) + const std::string& message) { nlohmann::json payload; payload["level"] = log_level; diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp index a0f48d093..b110ab718 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp @@ -181,15 +181,16 @@ bool is_credential_available(attribute_store_node_t endpoint_node, for_each_credential_type_nodes( endpoint_node, - [&](attribute_store::attribute &credential_type_node) { - for (auto &credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { + [&credential_available, &credential_slot]( + attribute_store::attribute ¤t_credential_type_node) { + for (auto ¤t_credential_slot_node: + current_credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { // If this credential slot node doesn't have a reported value, check the next one - if (!credential_slot_node.reported_exists()) { + if (!current_credential_slot_node.reported_exists()) { continue; } - if (credential_slot_node.reported() + if (current_credential_slot_node.reported() == credential_slot) { credential_available = false; return; diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 3f8a97512..69d15a814 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -73,13 +73,14 @@ using namespace user_credential_helpers; namespace { -zwave_frame_generator frame_generator(COMMAND_CLASS_USER_CREDENTIAL); +zwave_frame_generator frame_generator( + COMMAND_CLASS_USER_CREDENTIAL); //NOSONAR - false positive since it is warped in a namespace // Callbacks std::set - user_credential_slot_changed_callback; + user_credential_slot_changed_callback; //NOSONAR - false positive since it is warped in a namespace std::set - user_credential_slot_message_callback; + user_credential_slot_message_callback; //NOSONAR - false positive since it is warped in a namespace } // namespace ///////////////////////////////////////////////////////////////////////////// @@ -146,27 +147,23 @@ static void zwave_command_class_user_credential_on_version_attribute_update( sl_log_debug(LOG_TAG, "User Credential version %d", version); - attribute_store_node_t endpoint_node + attribute_store::attribute endpoint_node = attribute_store_get_first_parent_with_type(updated_node, ATTRIBUTE_ENDPOINT_ID); // The order of the attribute matter since it defines the order of the // Z-Wave get command order. - const attribute_store_type_t attributes[] = { - ATTRIBUTE(NUMBER_OF_USERS), - ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM), - }; - - attribute_store_add_if_missing(endpoint_node, - attributes, - COUNT_OF(attributes)); + endpoint_node.emplace_node(ATTRIBUTE(NUMBER_OF_USERS)); + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM)); } ///////////////////////////////////////////////////////////////////////////// // User Credential User Capabilities Get/Report ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_user_capabilities_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) { sl_log_debug(LOG_TAG, "User Capabilities Get"); @@ -229,7 +226,9 @@ sl_status_t zwave_command_class_user_credential_user_capabilities_handle_report( ///////////////////////////////////////////////////////////////////////////// static sl_status_t zwave_command_class_user_credential_credential_capabilities_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) { sl_log_debug(LOG_TAG, "Credential Capabilities Get"); @@ -263,12 +262,14 @@ sl_status_t } const uint8_t support_admin_code_bitmask = 0x40; - auto result = parser.read_byte_with_bitmask( + auto result = parser.read_byte_with_bitmask( {{CREDENTIAL_CAPABILITIES_REPORT_PROPERTIES1_CREDENTIAL_CHECKSUM_SUPPORT_BIT_MASK, - endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM))}, - {support_admin_code_bitmask, endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE))}, - {0x20, - endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION))}}); + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM))}, + {support_admin_code_bitmask, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE))}, + {0x20, + endpoint_node.emplace_node( + ATTRIBUTE(SUPPORT_ADMIN_PIN_CODE_DEACTIVATION))}}); if (result[support_admin_code_bitmask]) { endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE)); @@ -417,7 +418,9 @@ void add_user_node_to_checksum( } static sl_status_t zwave_command_class_user_credential_all_user_checksum_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) { sl_log_debug(LOG_TAG, "All Users Checksum Get"); @@ -631,8 +634,8 @@ enum class credential_report_type_t : uint8_t { }; sl_status_t - handle_credential_deletion(attribute_store::attribute &endpoint_node, - attribute_store::attribute &user_id_node, + handle_credential_deletion(attribute_store::attribute& endpoint_node, + attribute_store::attribute& user_id_node, user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_user_unique_id_t credential_slot) @@ -656,7 +659,7 @@ sl_status_t user_id); for_each_credential_type_nodes_for_user( user_id_node, - [&](attribute_store::attribute &credential_type_node) { + [](attribute_store::attribute &credential_type_node) { credential_type_node.delete_node(); }, credential_type); @@ -664,14 +667,14 @@ sl_status_t sl_log_info(LOG_TAG, "All credentials for user %d deleted.", user_id); for_each_credential_type_nodes_for_user( user_id_node, - [&](attribute_store::attribute &credential_type_node) { + [](attribute_store::attribute &credential_type_node) { credential_type_node.delete_node(); }); } else if (user_id == 0 && credential_type == 0 && credential_slot == 0) { sl_log_info(LOG_TAG, "All credentials deleted."); for_each_credential_type_nodes( endpoint_node, - [&](attribute_store::attribute &credential_type_node) { + [](attribute_store::attribute &credential_type_node) { credential_type_node.delete_node(); }); } else if (user_id == 0 && credential_type != 0 && credential_slot == 0) { @@ -680,7 +683,7 @@ sl_status_t get_credential_type_debug_str(credential_type).c_str()); for_each_credential_type_nodes( endpoint_node, - [&](attribute_store::attribute &credential_type_node) { + [](attribute_store::attribute &credential_type_node) { credential_type_node.delete_node(); }, credential_type); @@ -746,7 +749,7 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( credential_slot, get_credential_type_debug_str(credential_type).c_str(), user_id); - } catch (const std::exception &e) { + } catch (...) { // Try again with reported attribute // That should not trigger an error, but if it does it means that something went wrong auto nodes = get_credential_identifier_nodes( @@ -917,20 +920,24 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( // We need to find the credential slot node that contains the same data for_each_credential_type_nodes( endpoint_node, - [&](attribute_store::attribute &credential_type_node) { - for (auto &credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (credential_slot_node.desired_exists()) { + [&found_duplicate, &duplicate_data]( + attribute_store::attribute ¤t_credential_type_node) { + for (auto ¤t_credential_slot_node: + current_credential_type_node.children( + ATTRIBUTE(CREDENTIAL_SLOT))) { + if (current_credential_slot_node.desired_exists()) { auto current_data - = credential_slot_node + = current_credential_slot_node .child_by_type(ATTRIBUTE(CREDENTIAL_DATA)) .get>(DESIRED_OR_REPORTED_ATTRIBUTE); - if (current_data == duplicate_data) { - sl_log_debug( - LOG_TAG, - "Found the faulty credential slot node : %d", - credential_slot_node.desired()); - credential_slot_node.delete_node(); + if ( + current_data + == duplicate_data) { //NOSONAR - Don't have a better way to write this + sl_log_debug(LOG_TAG, + "Found the faulty credential slot node : %d", + current_credential_slot_node + .desired()); + current_credential_slot_node.delete_node(); found_duplicate = true; return; } @@ -972,7 +979,12 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( clean_up_pending_credentials_slot_nodes(); return SL_STATUS_OK; case credential_report_type_t::CREDENTIAL_DUPLICATE_ADMIN_CODE: - // TODO : Handle this case + sl_log_warning(LOG_TAG, + "Credential data rejected as the new credential is the " + "same as admin code"); + // This should contains the faulty credential + clean_up_pending_credentials_slot_nodes(); + break; default: sl_log_error(LOG_TAG, "Invalid credential report type %d", @@ -1409,7 +1421,7 @@ static sl_status_t zwave_command_class_user_credential_user_set( const bool is_delete_operation = (user_operation_type == USER_SET_OPERATION_TYPE_DELETE); - uint8_t expected_frame_size = (is_delete_operation) ? 5 : 12; + uint8_t expected_frame_size = is_delete_operation ? 5 : 12; uint8_t user_name_size = 0; if (!is_delete_operation) { @@ -1581,7 +1593,7 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID))) { // Don't delete special user 0 if (user_node.reported_exists() - && user_node.reported() == 0) { + && user_node.reported() == 0) { //NOSONAR - Don't have a better way to write this continue; } @@ -1654,8 +1666,6 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( // Deleted special case if (user_report_type == user_report_type_t::USER_DELETED) { - // TODO : move all credential from this user to user 0 - // Maybe it is done automatically by the credential report sl_log_info(LOG_TAG, "User %d has been deleted", current_user_id); current_user_id_node.delete_node(); return SL_STATUS_OK; @@ -1951,20 +1961,22 @@ sl_status_t user_credential::checksum_calculator checksum_calculator; for_each_credential_type_nodes( endpoint_node, - [&](auto credential_type_node) { - for (auto credential_slot_node: - credential_type_node.children(ATTRIBUTE(CREDENTIAL_SLOT))) { - if (!credential_slot_node.reported_exists()) { + [&checksum_calculator](auto current_credential_type_node) { + for (auto current_credential_slot_node: + current_credential_type_node.children( + ATTRIBUTE(CREDENTIAL_SLOT))) { + if (!current_credential_slot_node.reported_exists()) { sl_log_debug( LOG_TAG, "%s reported value is not defined. Not adding to checksum.", - credential_slot_node.value_to_string()); + current_credential_slot_node.value_to_string()); continue; } - checksum_calculator.add_node(credential_slot_node); + checksum_calculator.add_node(current_credential_slot_node); checksum_calculator.add_node( - credential_slot_node.child_by_type(ATTRIBUTE(CREDENTIAL_DATA))); + current_credential_slot_node.child_by_type( + ATTRIBUTE(CREDENTIAL_DATA))); } }, credential_type); @@ -2037,7 +2049,7 @@ static sl_status_t zwave_command_class_user_credential_admin_pin_code_set( frame_generator.initialize_frame(ADMIN_PIN_CODE_SET, frame, expected_frame_size); - + // In every case we add 0 to the frame frame_generator.add_raw_byte(admin_code_size); @@ -2058,11 +2070,15 @@ static sl_status_t zwave_command_class_user_credential_admin_pin_code_set( } static sl_status_t zwave_command_class_user_credential_admin_pin_code_get( - attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) { sl_log_debug(LOG_TAG, "Admin PIN Code Get"); // No definition yet for ADMIN_PIN_CODE_GET we use raw value - return frame_generator.generate_no_args_frame(ADMIN_PIN_CODE_GET, frame, frame_length); + return frame_generator.generate_no_args_frame(ADMIN_PIN_CODE_GET, + frame, + frame_length); } sl_status_t zwave_command_class_user_credential_admin_pin_code_handle_report( @@ -2090,10 +2106,10 @@ sl_status_t zwave_command_class_user_credential_admin_pin_code_handle_report( constexpr uint8_t admin_code_op_result_bitmask = 0b11110000; constexpr uint8_t admin_code_length_bitmask = 0b00001111; // First parse the code size and operation result - auto result = parser.read_byte_with_bitmask({ - {admin_code_op_result_bitmask, - endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE_OPERATION_RESULT))}, - {admin_code_length_bitmask}}); + auto result = parser.read_byte_with_bitmask( + {{admin_code_op_result_bitmask, + endpoint_node.emplace_node(ATTRIBUTE(ADMIN_PIN_CODE_OPERATION_RESULT))}, + {admin_code_length_bitmask}}); auto admin_code_op_result = result[admin_code_op_result_bitmask]; switch (admin_code_op_result) { @@ -2200,26 +2216,27 @@ void zwave_network_status_changed(attribute_store_node_t node, for (auto endpoint_node: node_id_node.children(ATTRIBUTE_ENDPOINT_ID)) { auto endpoint_id = endpoint_node.reported(); // Check if the endpoint supports User Credential Command class - if (zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, - node_id, - endpoint_id)) { - sl_log_debug(LOG_TAG, - "Endpoint %d supports User Credential.", - endpoint_id); - auto user_count - = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); - if (user_count == 0) { - sl_log_debug( - LOG_TAG, - "No user found. Starting User and Credential interview"); - // Start the interview process with user ID = 0 - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(0); - } else { - sl_log_debug(LOG_TAG, - "Users already discovered. No actions needed."); - } + if (!zwave_node_supports_command_class(COMMAND_CLASS_USER_CREDENTIAL, + node_id, + endpoint_id)) { + continue; + } + + sl_log_debug(LOG_TAG, + "Endpoint %d supports User Credential.", + endpoint_id); + auto user_count + = endpoint_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + if (user_count != 0) { + sl_log_debug(LOG_TAG, "Users already discovered. No actions needed."); + continue; } + + sl_log_debug(LOG_TAG, + "No user found. Starting User and Credential interview"); + // Start the interview process with user ID = 0 + endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) + .set_desired(0); } sl_log_debug(LOG_TAG, "Done."); } diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h index 8f6d9d63a..72ae89c33 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -48,7 +48,7 @@ sl_status_t zwave_command_class_user_credential_init(); #ifdef __cplusplus } // extern "C" typedef void (*user_credential_slot_message_callback_t)( - sl_log_level level, const std::string message); + sl_log_level level, const std::string& message); void zwave_command_class_user_credential_set_message_callback( user_credential_slot_message_callback_t callback); #endif From a09f5b3de538f89bd7dee228cfdd7c3f7f54bd2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 14 Oct 2024 15:34:20 +0200 Subject: [PATCH 56/60] UIC-3222: Fix User interview Now correctly interview ALL users on the first discovery (previously was only checking the first one due to a resolution error) All user checksum happens after all users & all credentials are reported --- .../zwave_command_class_user_credential.cpp | 120 ++++++++++++++++-- ...ave_command_class_user_credential_test.cpp | 44 ++++++- 2 files changed, 145 insertions(+), 19 deletions(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 69d15a814..105d67529 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -83,6 +83,101 @@ std::set user_credential_slot_message_callback; //NOSONAR - false positive since it is warped in a namespace } // namespace +/** + * @brief Keep track of the interview state + * + * User interview start with a get on User 0 to get the first user. + * We keep this node to store all the credentials that are not assigned to a user. + * + * So we need to set its reported in the first User Report otherwise the first GET will + * never be marked as resolved. + * + * We also need to keep track of the next user to interview, so we can first get all the + * credential for the current user before moving to the next one. + */ +namespace users_interview_state +{ +// WARNING : Use functions instead of those variables +// Next user ID to be interviewed +user_credential_user_unique_id_t next_user_id = 0; +// Special node for user 0 +// Used to resolve it in the report instead of in the get to prevent resolver issues +attribute_store::attribute user_0_node = ATTRIBUTE_STORE_INVALID_NODE; + +/** + * @brief Mark an node as the user 0 node + * + * @param node Node to mark as user 0 + */ +void set_user_0_node(attribute_store::attribute node) +{ + sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); + user_0_node = node; +} + +/** + * @brief Resolve user 0 if needed + */ +void resolve_user_0_node() +{ + if (user_0_node == ATTRIBUTE_STORE_INVALID_NODE) { + return; + } + + try { + user_0_node.set_reported(0); + user_0_node = ATTRIBUTE_STORE_INVALID_NODE; + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, "Error while setting user 0 node : %s", e.what()); + } +} + +/** + * @brief Schedule the next user interview + * + * @param user_id User ID to interview next + */ +void schedule_next_user_interview(user_credential_user_unique_id_t user_id) +{ + sl_log_debug(LOG_TAG, "Schedule a get for next User ID :%d", next_user_id); + next_user_id = user_id; +} + +/** + * @brief Trigger a get for the next user + * + * If there is not next user, we will trigger the all users checksum get + * (if supported) + * + * @param endpoint_node Current endpoint node + */ +void trigger_get_for_next_user(attribute_store::attribute endpoint_node) +{ + // If we get here it means that we have finished the interview for users and + // their credentials + if (next_user_id == 0) { + sl_log_debug(LOG_TAG, "User interview finished"); + // Check if we supports all users checksum to compute it + user_credential::user_capabilities capabilities(endpoint_node); + if (capabilities.is_all_users_checksum_supported()) { + // This will do nothing if the node already exists + // Otherwise it will trigger all_users_checksum_get + endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); + } + return; + } + + sl_log_debug(LOG_TAG, "Trigger a get for next User ID :%d", next_user_id); + + endpoint_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + next_user_id, + DESIRED_ATTRIBUTE); + + // Reset state + next_user_id = 0; +} +} // namespace users_interview_state + ///////////////////////////////////////////////////////////////////////////// // Callbacks ///////////////////////////////////////////////////////////////////////////// @@ -1036,6 +1131,8 @@ sl_status_t zwave_command_class_user_credential_credential_handle_report( next_credential_slot); } else { sl_log_debug(LOG_TAG, "No more credential to get."); + // Trigger the next user interview if any + users_interview_state::trigger_get_for_next_user(endpoint_node); } } catch (const std::exception &e) { @@ -1523,9 +1620,7 @@ static sl_status_t zwave_command_class_user_credential_user_get( // This special user ID will contains the unaffected credentials. if (user_id == 0) { - sl_log_debug(LOG_TAG, "Starting interview for all users on the device."); - user_unique_id_node.clear_desired(); - user_unique_id_node.set_reported(user_id); + users_interview_state::set_user_0_node(user_unique_id_node); } return SL_STATUS_OK; @@ -1553,6 +1648,10 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( attribute_store::attribute endpoint_node( zwave_command_class_get_endpoint_node(connection_info)); + // Resolve user 0 node if needed + // We need to do that here so that the attribute store mark this node as resolved + users_interview_state::resolve_user_0_node(); + const uint8_t expected_min_size = 16; try { @@ -1699,23 +1798,16 @@ sl_status_t zwave_command_class_user_credential_user_handle_report( if (next_user_id != 0 && user_report_type == user_report_type_t::RESPONSE_TO_GET) { if (!user_exists(endpoint_node, next_user_id)) { - sl_log_debug(LOG_TAG, "Trigger a get for next user (%d)", next_user_id); - endpoint_node.add_node(ATTRIBUTE(USER_UNIQUE_ID)) - .set_desired(next_user_id); + users_interview_state::schedule_next_user_interview(next_user_id); } else { sl_log_error(LOG_TAG, "User %d already exists. Not discovering more users.", next_user_id); } } else { - sl_log_debug(LOG_TAG, "No more users to discover"); - // Check if we supports all users checksum to compute it - user_credential::user_capabilities capabilities(endpoint_node); - if (capabilities.is_all_users_checksum_supported()) { - // This will do nothing if the node already exists - // Otherwise it will trigger all_users_checksum_get - endpoint_node.emplace_node(ATTRIBUTE(ALL_USERS_CHECKSUM)); - } + sl_log_debug(LOG_TAG, + "User %d is the last user to be discovered.", + current_user_id); } } catch (const std::exception &e) { sl_log_error(LOG_TAG, diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 4a078c9f9..71f2fc65a 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -1001,20 +1001,43 @@ void test_user_credential_user_report_happy_case() // Test structure auto user_id_count = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); - TEST_ASSERT_EQUAL_MESSAGE( - 3, - user_id_count, - "User node count mismatch. Should be 3 by now. One with special id 0, the " - "reported one and the new desired one"); + TEST_ASSERT_EQUAL_MESSAGE(2, + user_id_count, + "User node count mismatch. Should be 2 by now. One " + "with special id 0 and the " + "reported one"); + // Simulate no credential for this User + helper_simulate_credential_report_frame(0x00, + user_id, + 0, + 0, + 0, + std::vector(), + 0, + 0, + 0, + 0); auto second_user_id_node = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(USER_UNIQUE_ID), 2); + + TEST_ASSERT_TRUE_MESSAGE( + second_user_id_node.is_valid(), + "Second user node should be created & valid"); TEST_ASSERT_FALSE_MESSAGE( cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)) .is_valid(), "ALL_USERS_CHECKSUM node should not be created yet"); + user_id_count + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + TEST_ASSERT_EQUAL_MESSAGE( + 3, + user_id_count, + "User node count mismatch. Should be 3 by now. One " + "with special id 0, the reported one & the next in queue"); + printf("Second and last user creation\n"); TEST_ASSERT_EQUAL_MESSAGE( @@ -1074,6 +1097,17 @@ void test_user_credential_user_report_happy_case() second_user_id_node.reported(), "Second user id mismatch"); + // Still no credential, so we can create the all user checksum + helper_simulate_credential_report_frame(0x00, + user_id, + 0, + 0, + 0, + std::vector(), + 0, + 0, + 0, + 0); TEST_ASSERT_TRUE_MESSAGE( cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)) .is_valid(), From bc3cb4bebbd45e1f37c37845251a04106bd88c03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 14 Oct 2024 15:34:46 +0200 Subject: [PATCH 57/60] UIC-3222: Fix error message on network status wake up --- .../src/zwave_command_class_user_credential.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp index 105d67529..b44bf5466 100644 --- a/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -2292,7 +2292,12 @@ void zwave_network_status_changed(attribute_store_node_t node, auto node_id = node_id_node.reported(); // If we are updating the zpc node or if we trying to delete the attribute we don't want to do anything - if (change == ATTRIBUTE_DELETED || get_zpc_node_id_node() == node_id_node) { + if (change != ATTRIBUTE_UPDATED || get_zpc_node_id_node() == node_id_node) { + return; + } + + // In case we are not ready yet and don't have a reported value + if (!network_status_node.reported_exists()) { return; } From 44b23fae0d2af3cadadfed16eb3bcb2fe231c1c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Mon, 14 Oct 2024 16:33:52 +0200 Subject: [PATCH 58/60] UIC-3222: Python script for User Credential CTT --- .../clusters/user_credential.py | 73 ++++++++++++++ .../command_classes/user_credential.py | 98 +++++++++++++++++++ 2 files changed, 171 insertions(+) create mode 100644 applications/zpc/scripts/certification/command_classes/clusters/user_credential.py create mode 100644 applications/zpc/scripts/certification/command_classes/user_credential.py diff --git a/applications/zpc/scripts/certification/command_classes/clusters/user_credential.py b/applications/zpc/scripts/certification/command_classes/clusters/user_credential.py new file mode 100644 index 000000000..9ae934406 --- /dev/null +++ b/applications/zpc/scripts/certification/command_classes/clusters/user_credential.py @@ -0,0 +1,73 @@ +import mqtt.mqtt_manager as mqtt_manager +import utils.utils as utils + +CLUSTER_NAME = "UserCredential" + + +class CredentialType: + PINCode = "PINCode" + Password = "Password" + RFIDCode = "RFIDCode" + BLE = "BLE" + NFC = "NFC" + UWB = "UWB" + EyeBiometric = "EyeBiometric" + FaceBiometric = "FaceBiometric" + FingerBiometric = "FingerBiometric" + HandBiometric = "HandBiometric" + UnspecifiedBiometric = "UnspecifiedBiometric" + + + + + + +def add_user(user_id): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "AddUser", + '{"UserUniqueID":%d,"UserType":"GeneralUser","UserActiveState":true,"CredentialRule":"Single","UserName":"","ExpiringTimeoutMinutes":0,"UserNameEncoding":"ASCII"}' % user_id) + +def modify_user(user_id, user_name): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "ModifyUser", + '{"UserUniqueID":%d,"UserType":"GeneralUser","UserActiveState":true,"CredentialRule":"Single","UserName":"%s","ExpiringTimeoutMinutes":0,"UserNameEncoding":"ASCII"}' % (user_id, user_name)) + +def delete_user(user_id): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteUser", + '{"UserUniqueID":%d}' % user_id) + +def add_credential(user_id, credential_type, credential_slot, credential_data): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "AddCredential", + '{"UserUniqueID":%d,"CredentialType":"%s","CredentialSlot":%d,"CredentialData":"%s"}' % (user_id, credential_type, credential_slot, credential_data)) + +def modify_credential(user_id, credential_type, credential_slot, credential_data): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "ModifyCredential", + '{"UserUniqueID":%d,"CredentialType":"%s","CredentialSlot":%d,"CredentialData":"%s"}' % (user_id, credential_type, credential_slot, credential_data)) + +def delete_credential(user_id, credential_type, credential_slot): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteCredential", + '{"UserUniqueID":%d,"CredentialType":"%s","CredentialSlot":%d}' % (user_id, credential_type, credential_slot)) + + +def delete_all_users(): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteAllUsers") + +def delete_credential_for_user_by_type(user_id, credential_type): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteAllCredentialsForUserByType", + '{"UserUniqueID":%d,"CredentialType":"%s"}' % (user_id, credential_type)) + +def delete_all_credentials_for_user(user_id): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteAllCredentialsForUser", + '{"UserUniqueID":%d}' % user_id) + +def delete_all_credentials(): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteAllCredentials") + +def delete_all_credential_types(credentials_type): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeleteAllCredentialsByType", + '{"CredentialType":"%s"}' % credentials_type) + +def set_admin_pin_code(admin_pin_code): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "SetAdminPINCode", + '{"PINCode":"%s"}' % admin_pin_code) + +def deactivate_admin_pin_code(): + mqtt_manager.send_unify_cluster_command(CLUSTER_NAME, "DeactivateAdminPINCode") \ No newline at end of file diff --git a/applications/zpc/scripts/certification/command_classes/user_credential.py b/applications/zpc/scripts/certification/command_classes/user_credential.py new file mode 100644 index 000000000..71dc20b81 --- /dev/null +++ b/applications/zpc/scripts/certification/command_classes/user_credential.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 + +import mqtt.mqtt_manager as mqtt_manager +import utils.pretty_print as display + +from clusters import user_credential + +# Data for the test +# New user +NEW_USER_ID = 1 +NEW_USER_NAME = "SHOCKBAR" +# New Credential +NEW_CREDENTIAL_TYPE = user_credential.CredentialType.PINCode +NEW_CREDENTIAL_SLOT = 1 +NEW_CREDENTIAL_ORIGINAL_PIN_CODE = "1273" +NEW_CREDENTIAL_MODIFIED_PIN_CODE = "1291" + +# Credential to be deleted +DELETED_CREDENTIAL_TYPE = user_credential.CredentialType.PINCode +DELETED_USER_ID = 1 + +# Taken from CTT test case +NEW_ADMIN_PIN_CODE = "0112358" + +def add_user(): + display.action_description(f"Adding User #{NEW_USER_ID}") + user_credential.add_user(NEW_USER_ID) + +def modify_user(): + display.action_description(f"Modifying Username of User #{NEW_USER_ID} to {NEW_USER_NAME}") + user_credential.modify_user(NEW_USER_ID, NEW_USER_NAME) + +def add_credential(): + display.action_description(f"Adding Credential for User #{NEW_USER_ID}") + user_credential.add_credential(NEW_USER_ID, NEW_CREDENTIAL_TYPE, NEW_CREDENTIAL_SLOT, NEW_CREDENTIAL_ORIGINAL_PIN_CODE) + +def modify_credential(): + display.action_description(f"Modifying Credential for User #{NEW_USER_ID}") + user_credential.modify_credential(NEW_USER_ID, NEW_CREDENTIAL_TYPE, NEW_CREDENTIAL_SLOT, NEW_CREDENTIAL_MODIFIED_PIN_CODE) + +def delete_credential(): + display.action_description(f"Removing Credential for User #{NEW_USER_ID}") + user_credential.delete_credential(NEW_USER_ID, NEW_CREDENTIAL_TYPE, NEW_CREDENTIAL_SLOT) + +def delete_user(): + display.action_description(f"Removing User #{NEW_USER_ID}") + user_credential.delete_user(NEW_USER_ID) + +def delete_all_users(): + display.action_description(f"Removing All Users") + user_credential.delete_all_users() + +def delete_credential_for_user_by_type(): + display.action_description(f"Removing Credential Type {DELETED_CREDENTIAL_TYPE} for User #{NEW_USER_ID}") + user_credential.delete_credential_for_user_by_type(DELETED_USER_ID, DELETED_CREDENTIAL_TYPE) + +def delete_all_credentials_for_user(): + display.action_description(f"Removing All Credentials for User #{NEW_USER_ID}") + user_credential.delete_all_credentials_for_user(DELETED_USER_ID) + +def delete_all_credentials(): + display.action_description(f"Removing All Credentials") + user_credential.delete_all_credentials() + +def delete_all_credential_types(): + display.action_description(f"Removing All Credential Types : {DELETED_CREDENTIAL_TYPE}") + user_credential.delete_all_credential_types(DELETED_CREDENTIAL_TYPE) + +def set_admin_pin_code(): + display.action_description(f"Setting Admin Pin Code to #{NEW_ADMIN_PIN_CODE}") + user_credential.set_admin_pin_code(NEW_ADMIN_PIN_CODE) + +def deactivate_admin_pin_code(): + display.action_description(f"Deactivating Admin Pin Code") + user_credential.deactivate_admin_pin_code() + +if __name__ == '__main__': + mqtt_manager.add_node() + + add_user() + modify_user() + + add_credential() + modify_credential() + delete_credential() + + delete_user() + + delete_all_users() + delete_credential_for_user_by_type() + delete_all_credentials_for_user() + delete_all_credentials() + delete_all_credential_types() + + set_admin_pin_code() + deactivate_admin_pin_code() + + mqtt_manager.remove_node() From 6bfff4159dba8f0769f6a3d3f89d7fe38d2071a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Boris=20Labb=C3=A9?= Date: Tue, 22 Oct 2024 15:35:03 +0200 Subject: [PATCH 59/60] UIC-3222: Use raw data for credentials that are not PinCode or password --- .../src/user_credential_cluster_server.cpp | 81 +++++++++++-------- .../user_credential_cluster_server_test.cpp | 42 ++++++---- ...redential_credential_type_capabilities.cpp | 20 ++++- ...ave_command_class_user_credential_test.cpp | 29 +++++-- 4 files changed, 116 insertions(+), 56 deletions(-) diff --git a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp index 4afbf6f69..6cc3e2331 100644 --- a/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -877,8 +877,7 @@ std::string mqtt_topic_add_attribute(const std::string &base_mqtt_topic, * @return The payload value. */ std::string get_payload_value(attribute_store::attribute updated_node_cpp, - mqtt_data data, - bool need_utf8_conversion = false) + std::function convert_function = nullptr) { std::string payload_str = ""; @@ -899,32 +898,15 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, json_payload["value"] = updated_node_cpp.reported(); break; case BYTE_ARRAY_STORAGE_TYPE: { - // Convert the byte array to a string - // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value - - std::string output; + // Convert the byte array to a string that contains the hex representation auto raw_data = updated_node_cpp.reported>(); - // Check if we need to convert the value to UTF-8 - if (need_utf8_conversion) { - std::u16string utf16_str; - for (size_t i = 0; i < raw_data.size(); i += 2) { - char16_t char16 = (raw_data[i] << 8) | raw_data[i + 1]; - utf16_str.push_back(char16); - } - std::wstring_convert, char16_t> cnv; - output = cnv.to_bytes(utf16_str); - if (cnv.converted() < utf16_str.size()) { - sl_log_error(LOG_TAG, "Error converting UTF-16 to UTF-8"); - } - } else { - output.reserve(raw_data.size()); - for (auto c: raw_data) { - output.push_back(static_cast(c)); - } + std::stringstream ss; + ss << std::hex << std::setfill('0'); + for(auto c : raw_data) { + ss << std::setw(2) << static_cast(c); } - - json_payload["value"] = output; + json_payload["value"] = ss.str(); } break; default: @@ -934,15 +916,14 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, } // Check if we need to convert the enum to a string - const auto &enum_name_conversion = data.convert_function; - if (enum_name_conversion) { - json_payload["value"] = enum_name_conversion(json_payload["value"]); + if (convert_function) { + json_payload["value"] = convert_function(json_payload["value"]); } // Create payload payload_str = json_payload.dump(); // Handle booleans - if (enum_name_conversion) { + if (convert_function) { boost::replace_all(payload_str, "\"true\"", "true"); boost::replace_all(payload_str, "\"false\"", "false"); } @@ -950,6 +931,42 @@ std::string get_payload_value(attribute_store::attribute updated_node_cpp, return payload_str; } +std::string + get_credential_data_value(attribute_store::attribute updated_node_cpp, + user_credential_type_t type) +{ + std::string output; + + auto raw_data = updated_node_cpp.reported>(); + // Convert the byte array to a string + // Credential data are encoded in different way that's why we store them as raw byte array and interpret their value + switch (type) { + case ZCL_CRED_TYPE_PIN_CODE: + output.reserve(raw_data.size()); + for (auto c: raw_data) { + output.push_back(static_cast(c)); + } + break; + case ZCL_CRED_TYPE_PASSWORD: { + std::u16string utf16_str; + for (size_t i = 0; i < raw_data.size(); i += 2) { + char16_t char16 = (raw_data[i] << 8) | raw_data[i + 1]; + utf16_str.push_back(char16); + } + std::wstring_convert, char16_t> cnv; + output = cnv.to_bytes(utf16_str); + if (cnv.converted() < utf16_str.size()) { + sl_log_error(LOG_TAG, "Error converting UTF-16 to UTF-8"); + } + } break; + default: + return get_payload_value(updated_node_cpp); + } + nlohmann::json json_payload; + json_payload["value"] = output; + return json_payload.dump(); +} + void publish_mqtt_topic(const std::string &base_topic, mqtt_data data, attribute_store::attribute updated_node_cpp, @@ -966,11 +983,9 @@ void publish_mqtt_topic(const std::string &base_topic, user_credential_type_t type = updated_node_cpp.first_parent(ATTRIBUTE(CREDENTIAL_TYPE)) .reported(); - payload_str = get_payload_value(updated_node_cpp, - data, - (type == ZCL_CRED_TYPE_PASSWORD)); + payload_str = get_credential_data_value(updated_node_cpp, type); } else { - payload_str = get_payload_value(updated_node_cpp, data); + payload_str = get_payload_value(updated_node_cpp, data.convert_function); } if (payload_str.empty()) { return; diff --git a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp index f9e8d1e1f..df2d9df92 100644 --- a/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -798,7 +798,8 @@ attribute_store_node_t helper_add_complete_credential(user_credential_user_unique_id_t user_id, user_credential_type_t credential_type, user_credential_slot_t credential_slot, - const char *credential_data) + const char *credential_data, + std::vector expected_credential_data_vector = {}) { attribute_store_node_t user_id_node = helper_add_user_id(user_id); @@ -826,10 +827,12 @@ attribute_store_node_t credential_data_vector.push_back((uint8_t)(c >> 8)); credential_data_vector.push_back((uint8_t)c); } - } else { + } else if (credential_type == ZCL_CRED_TYPE_PIN_CODE) { credential_data_vector = std::vector(cpp_str_credential_data.begin(), cpp_str_credential_data.end()); + } else { + credential_data_vector = expected_credential_data_vector; } mock_expected_cred_mqtt_topic( @@ -980,13 +983,15 @@ void helper_test_desired_user_attributes( "Expiring Timeout mismatch"); } +// Need to specify credential_data_vector if credential_type is not ZCL_CRED_TYPE_PIN_CODE or ZCL_CRED_TYPE_PASSWORD void helper_test_desired_credential_attributes( user_credential_user_unique_id_t user_id_node, user_credential_type_t credential_type, user_credential_slot_t credential_slot, const char *credential_data, bool desired_credential_identifiers, - user_credential_operation_type_t credential_operation_type) + user_credential_operation_type_t credential_operation_type, + std::vector credential_data_vector = {}) { attribute_store_node_value_state_t credential_identifier_state = desired_credential_identifiers ? DESIRED_ATTRIBUTE : REPORTED_ATTRIBUTE; @@ -1031,11 +1036,13 @@ void helper_test_desired_credential_attributes( expected_credential_data_vector.push_back((uint8_t)(c >> 8)); expected_credential_data_vector.push_back((uint8_t)c); } - } else { + } else if (credential_type == ZCL_CRED_TYPE_PIN_CODE) { // Should be in ascii we can convert it expected_credential_data_vector = std::vector(str_credential_data.begin(), str_credential_data.end()); - } + } else { + expected_credential_data_vector = credential_data_vector; + } // Credential Data attribute_store::attribute credential_data_node @@ -1486,7 +1493,7 @@ void test_user_credential_cluster_add_credential_others_happy_case() user_credential_user_unique_id_t user_unique_id = 12; CredType credential_type = CredType::ZCL_CRED_TYPE_RFID_CODE; user_credential_slot_t credential_slot = 1; - const char *credential_data = "hunter2"; + const char *credential_data = "abcdef123456"; // Add simple user helper_add_user_id(user_unique_id); @@ -1515,7 +1522,8 @@ void test_user_credential_cluster_add_credential_others_happy_case() credential_slot, credential_data, true, - USER_CREDENTIAL_OPERATION_TYPE_ADD); + USER_CREDENTIAL_OPERATION_TYPE_ADD, + {0xab, 0xcd, 0xef, 0x12, 0x34, 0x56}); } /////////////////////////////////////////////////// @@ -1661,14 +1669,15 @@ void test_user_credential_cluster_modify_credential_others_happy_case() user_credential_user_unique_id_t user_unique_id = 12; CredType credential_type = CredType::ZCL_CRED_TYPE_BLE; user_credential_slot_t credential_slot = 2; - std::string credential_data = "FAST TURBO ENGINE DOG PRO MAX"; + std::string credential_data = "cafe12"; auto user_id_node = helper_add_complete_credential(user_unique_id, credential_type, credential_slot, - credential_data.c_str()); - // Test UTF-16 conversion for password - credential_data = "FAE124A54E5F9325874A23E3646B"; + credential_data.c_str(), + {0xca, 0xfe, 0x12}); + // New data + credential_data = "eF12Ca"; TEST_ASSERT_EQUAL_MESSAGE( SL_STATUS_OK, modify_credential_command(supporting_node_unid, @@ -1686,7 +1695,8 @@ void test_user_credential_cluster_modify_credential_others_happy_case() credential_slot, credential_data.c_str(), false, - USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + USER_CREDENTIAL_OPERATION_TYPE_MODIFY, + {0xef, 0x12, 0xca}); } /////////////////////////////////////////////////// @@ -1829,7 +1839,7 @@ void test_user_credential_cluster_delete_all_credential_happy_case() user_credential_slot_t credential_slot = 0; std::vector user_ids = {12, 12, 12, 15, 19}; - std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_types = {1, 1, 2, 2, 1}; std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size @@ -1888,7 +1898,7 @@ void test_user_credential_cluster_delete_all_credential_for_user_happy_case() std::vector user_ids = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; - std::vector credential_types = {1, 1, 2, 5, 1}; + std::vector credential_types = {1, 1, 2, 2, 1}; std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size @@ -1950,7 +1960,7 @@ void test_user_credential_cluster_delete_all_credential_for_user_by_type_happy_c std::vector user_ids = {user_unique_id, user_unique_id, user_unique_id, 15, 19}; std::vector credential_types - = {credential_type, credential_type, 2, 5, credential_type}; + = {credential_type, credential_type, 2, 2, credential_type}; std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size @@ -2012,7 +2022,7 @@ void test_user_credential_cluster_delete_all_credential_by_type_happy_case() std::vector user_ids = {12, 12, 12, 15, 19}; std::vector credential_types - = {credential_type, credential_type, 2, 5, credential_type}; + = {credential_type, credential_type, 2, 2, credential_type}; std::vector credential_slots = {1, 2, 2, 1, 3}; // WARNING : Make sure that all the vector above have the same size diff --git a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp index 8d434a7ac..a2df80fbb 100644 --- a/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp @@ -20,6 +20,7 @@ // Needed for credential data (password) per specification #include #include +#include // std::regex_replace // Boost #include @@ -183,8 +184,23 @@ std::vector } break; default: - for (const auto &c: credential_data_str) { - credential_data_vector.push_back(c); + if (credential_data_str.size() % 2 != 0) { + throw std::runtime_error( + "Credential data size is not valid. Should be even since it expect raw hexa."); + } + if (!std::regex_match(credential_data_str, std::regex("[0-9a-fA-F]+"))) { + throw std::runtime_error( + "Credential data is not valid. It should be a raw hexa string (e.g. CAFE1234)."); + } + + std::stringstream ss; + int value; + for (size_t i = 0; i < credential_data_str.size(); i += 2) { + ss.clear(); + auto sub_str = credential_data_str.substr(i, 2); + ss << std::hex << sub_str; + ss >> value; + credential_data_vector.push_back(value); } } diff --git a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp index 71f2fc65a..ed0af695e 100644 --- a/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -2544,7 +2544,7 @@ void test_user_credential_credential_add_capabilites_happy_case() user_id, ZCL_CRED_TYPE_HAND_BIOMETRIC, 1, - "TURBO"), + "ABCD"), "Credential #1 should be valid"); TEST_ASSERT_EQUAL_MESSAGE( @@ -2577,7 +2577,7 @@ void test_user_credential_credential_modify_capabilites_failure_cases() std::vector supported_cl = {1}; std::vector supported_credential_slots = {1}; std::vector supported_cred_min_length = {2}; - std::vector supported_cred_max_length = {7}; + std::vector supported_cred_max_length = {17}; helper_simulate_credential_capabilites_report(supported_credential_checksum, support_admin_code, support_admin_code_deactivation, @@ -2595,7 +2595,7 @@ void test_user_credential_credential_modify_capabilites_failure_cases() user_id, ZCL_CRED_TYPE_HAND_BIOMETRIC, 1, - "VOITURE"), + "ABCDEF0123456789"), "Should be able to add credential"); TEST_ASSERT_EQUAL_MESSAGE( @@ -2605,7 +2605,7 @@ void test_user_credential_credential_modify_capabilites_failure_cases() user_id, ZCL_CRED_TYPE_HAND_BIOMETRIC, 1, - "V"), + "A"), "Should not be able to modify credential data : it's too short"); TEST_ASSERT_EQUAL_MESSAGE( @@ -2615,8 +2615,27 @@ void test_user_credential_credential_modify_capabilites_failure_cases() user_id, ZCL_CRED_TYPE_HAND_BIOMETRIC, 1, - "MAX SPEEEEEEEEEEEEED TURBO"), + "ABCDEF0123456789A"), "Should not be able to modify credential data : it's too long"); + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "TURBO"), + "Should not be able to modify credential data : it's not hexa"); + + TEST_ASSERT_EQUAL_MESSAGE( + SL_STATUS_FAIL, + zwave_command_class_user_credential_modify_credential( + endpoint_id_node, + user_id, + ZCL_CRED_TYPE_HAND_BIOMETRIC, + 1, + "AAB"), + "Should not be able to modify credential data : odd size for hexa value"); } void helper_test_credential_rejected_case(uint8_t report_type) From 20ea3385345cdbc98aa825cab5ada68bf036e21b Mon Sep 17 00:00:00 2001 From: Philippe Coval Date: Tue, 7 Oct 2025 12:10:23 +0200 Subject: [PATCH 60/60] feat(u3c): Add test on simulated lock app Feel free to stress test by doing negative testing and changes usernames (using spaces or escapes). May delete commands produce retained events. Further negative testing will not hurt. Relate-to: https://github.com/SiliconLabsSoftware/z-wave-protocol-controller/pull/144/ Signed-off-by: Philippe Coval --- scripts/tests/z-wave-stack-binaries-test.sh | 86 +++++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/scripts/tests/z-wave-stack-binaries-test.sh b/scripts/tests/z-wave-stack-binaries-test.sh index 4f75cc0de..3738f5ae1 100755 --- a/scripts/tests/z-wave-stack-binaries-test.sh +++ b/scripts/tests/z-wave-stack-binaries-test.sh @@ -606,6 +606,92 @@ play_node_soc_door_lock_keypad_() json='{"value":"'$value'"}' expect="$sub $json" pubsub_ "$pub" "$message" "$sub" "$expect" + + type="UserCredential" + command="AddUser" + ep="ep0/$type/Commands/$command" + pub="ucl/by-unid/$nodeunid/$ep" + local userid=1 + local usertype='ProgrammingUser' + + message=' +{ + "UserUniqueID": '$userid', + "UserType": "'$usertype'", + "UserActiveState": false, + "CredentialRule": "Single", + "UserName": "Admin", + "ExpiringTimeoutMinutes": 0, + "UserNameEncoding": "ASCII" +} +' + sub="ucl/by-unid/$nodeunid/ep0/$type/Attributes/User/$userid/UserName/Reported" + expect='{"value":"Admin"}' + expect="$sub $expect" + pubsub_ "$pub" "$message" "$sub" "$expect" + + userid=2 + usertype='GeneralUser' + message=' +{ + "UserUniqueID": '$userid', + "UserType": "'$usertype'", + "UserActiveState": false, + "CredentialRule": "Single", + "UserName": "", + "ExpiringTimeoutMinutes": 0, + "UserNameEncoding": "ASCII" +} +' + sub="ucl/by-unid/$nodeunid/ep0/$type/Attributes/User/$userid/UserName/Reported" + expect='{"value":"User-'$userid'"}' + expect="$sub $expect" + pubsub_ "$pub" "$message" "$sub" "$expect" + + command='AddCredential' + ep="ep0/$type/Commands/$command" + pub="ucl/by-unid/$nodeunid/$ep" + value=1234 + message='{ + "UserUniqueID": '$userid', + "CredentialType": "PINCode", + "CredentialSlot": 5, + "CredentialData": "'$value'" +}' + ep="ep0/UserCredential/Attributes/User/2/Credential/PINCode/5/CredentialData/Reported" + sub="ucl/by-unid/$nodeunid/$ep" + expect='{"value":"'$value'"}' + expect="$sub $expect" + pubsub_ "$pub" "$message" "$sub" "$expect" + + command='ModifyCredential' + ep="ep0/$type/Commands/$command" + pub="ucl/by-unid/$nodeunid/$ep" + value=5678 + message='{ + "UserUniqueID": '$userid', + "CredentialType": "PINCode", + "CredentialSlot": 5, + "CredentialData": "'$value'" +}' + expect='{"value":"'$value'"}' + expect="$sub $expect" + pubsub_ "$pub" "$message" "$sub" "$expect" + + command='DeleteAllCredentials' + ep="ep0/$type/Commands/$command" + pub="ucl/by-unid/$nodeunid/$ep" + message='{}' + sub="ucl/by-unid/$nodeunid/ep0/$type/Attributes/User/+/Credential/PINCode/+/CredentialModifierNodeId/Reported" + expect="$sub (null)" + pub_ "$pub" "$message" # Not retained ? + + command="DeleteAllUsers" + ep="ep0/$type/Commands/$command" + pub="ucl/by-unid/$nodeunid/$ep" + message='{}' + sub="ucl/by-unid/$nodeunid/ep0/UserCredential/Attributes/User/1/UserName/Reported" + pub_ "$pub" "$message" # Not retained ? }